if (typeof Blockly === 'undefined') {
    var Blockly = {};
}
// translations
Blockly.Words = {};

// --- ACTION --------------------------------------------------
Blockly.Words['Action']                               = {'en': 'Actions',                                         'de': 'Aktionen',                                        'ru': 'Действия',                                        'pt': 'Ações',                                           'nl': 'Acties',                                          'fr': 'Actes',                                           'it': 'Azioni',                                          'es': 'Comportamiento'};

// --- action exec --------------------------------------------------
Blockly.Words['exec']                                 = {'en': 'exec',                                            'de': 'exec',                                            'ru': 'exec',                                            'pt': 'exec',                                            'nl': 'exec',                                            'fr': 'exec',                                            'it': 'exec',                                            'es': 'ejecutivo'};
Blockly.Words['exec_statement']                       = {'en': 'with results',                                    'de': 'mit Ergebnissen',                                 'ru': 'анализировать результаты',                        'pt': 'com resultados',                                  'nl': 'met resultaten',                                  'fr': 'avec des résultats',                              'it': 'con risultati',                                   'es': 'con resultados'};
Blockly.Words['exec_command']                         = {'en': 'command',                                         'de': 'Befehl',                                          'ru': 'команда',                                         'pt': 'comando',                                         'nl': 'opdracht',                                        'fr': 'commander',                                       'it': 'comando',                                         'es': 'mando'};
Blockly.Words['exec_tooltip']                         = {'en': 'Execute some command',                            'de': 'Einen System-Befehl ausführen',                   'ru': 'Выполнить системную команду',                     'pt': 'Execute algum comando',                           'nl': 'Voer een commando uit',                           'fr': 'Exécuter une commande',                           'it': 'Esegui un comando',                               'es': 'Ejecuta algún comando'};
Blockly.Words['exec_help']                            = {'en': 'exec---execute-some-os-command-like-cp-file1-file2', 'de': 'exec---execute-some-os-command-like-cp-file1-file2', 'ru': 'exec---execute-some-os-command-like-cp-file1-file2', 'pt': 'exec---execute-some-os-command-like-cp-file1-file2', 'nl': 'exec---execute-some-os-command-like-cp-file1-file2', 'fr': 'exec---execute-some-os-command-like-cp-file1-file2', 'it': 'exec---execute-some-os-command-like-cp-file1-file2', 'es': 'exec---execute-some-os-command-like-cp-file1-file2'};
Blockly.Words['exec_log']                             = {'en': 'log level',                                       'de': 'Loglevel',                                        'ru': 'Протокол',                                        'pt': 'nível de log',                                    'nl': 'Log niveau',                                      'fr': 'niveau de journalisation',                        'it': 'livello di registro',                             'es': 'nivel de registro'};
Blockly.Words['exec_log_none']                        = {'en': 'none',                                            'de': 'keins',                                           'ru': 'нет',                                             'pt': 'Nenhum',                                          'nl': 'geen',                                            'fr': 'aucun',                                           'it': 'nessuna',                                         'es': 'ninguna'};
Blockly.Words['exec_log_info']                        = {'en': 'info',                                            'de': 'info',                                            'ru': 'инфо',                                            'pt': 'informação',                                      'nl': 'info',                                            'fr': 'Info',                                            'it': 'Informazioni',                                    'es': 'información'};
Blockly.Words['exec_log_debug']                       = {'en': 'debug',                                           'de': 'debug',                                           'ru': 'debug',                                           'pt': 'depurar',                                         'nl': 'debug',                                           'fr': 'déboguer',                                        'it': 'mettere a punto',                                 'es': 'depurar'};
Blockly.Words['exec_log_warn']                        = {'en': 'warning',                                         'de': 'warning',                                         'ru': 'warning',                                         'pt': 'Atenção',                                         'nl': 'waarschuwing',                                    'fr': 'Attention',                                       'it': 'avvertimento',                                    'es': 'advertencia'};
Blockly.Words['exec_log_error']                       = {'en': 'error',                                           'de': 'error',                                           'ru': 'ошибка',                                          'pt': 'erro',                                            'nl': 'fout',                                            'fr': 'Erreur',                                          'it': 'errore',                                          'es': 'error'};

// --- action request --------------------------------------------------
Blockly.Words['request']                              = {'en': 'request',                                         'de': 'request',                                         'ru': 'request',                                         'pt': 'pedido',                                          'nl': 'verzoek',                                         'fr': 'demande',                                         'it': 'richiesta',                                       'es': 'solicitud'};
Blockly.Words['request_url']                          = {'en': 'URL',                                             'de': 'URL',                                             'ru': 'URL',                                             'pt': 'URL',                                             'nl': 'URL',                                             'fr': 'URL',                                             'it': 'URL',                                             'es': 'URL'};
Blockly.Words['request_statement']                    = {'en': 'with results',                                    'de': 'mit Ergebnissen',                                 'ru': 'анализировать результаты',                        'pt': 'com resultados',                                  'nl': 'met resultaten',                                  'fr': 'avec des résultats',                              'it': 'con risultati',                                   'es': 'con resultados'};
Blockly.Words['request_tooltip']                      = {'en': 'Request URL',                                     'de': 'URL abfragen',                                    'ru': 'Запросить URL',                                   'pt': 'URL do pedido',                                   'nl': 'Verzoek om URL',                                  'fr': 'Demander une URL',                                'it': 'URL di richiesta',                                'es': 'URL de solicitud'};
Blockly.Words['request_help']                         = {'en': 'https://git.spacen.net/request/request',              'de': 'https://git.spacen.net/request/request',              'ru': 'https://git.spacen.net/request/request',              'pt': 'https://git.spacen.net/request/request',              'nl': 'https://git.spacen.net/request/request',              'fr': 'https://git.spacen.net/request/request',              'it': 'https://git.spacen.net/request/request',              'es': 'https://git.spacen.net/request/request'};
Blockly.Words['request_log']                          = {'en': 'log level',                                       'de': 'Loglevel',                                        'ru': 'Протокол',                                        'pt': 'nível de log',                                    'nl': 'Log niveau',                                      'fr': 'niveau de journalisation',                        'it': 'livello di registro',                             'es': 'nivel de registro'};
Blockly.Words['request_log_none']                     = {'en': 'none',                                            'de': 'keins',                                           'ru': 'нет',                                             'pt': 'Nenhum',                                          'nl': 'geen',                                            'fr': 'aucun',                                           'it': 'nessuna',                                         'es': 'ninguna'};
Blockly.Words['request_log_info']                     = {'en': 'info',                                            'de': 'info',                                            'ru': 'инфо',                                            'pt': 'informação',                                      'nl': 'info',                                            'fr': 'Info',                                            'it': 'Informazioni',                                    'es': 'información'};
Blockly.Words['request_log_debug']                    = {'en': 'debug',                                           'de': 'debug',                                           'ru': 'debug',                                           'pt': 'depurar',                                         'nl': 'debug',                                           'fr': 'déboguer',                                        'it': 'mettere a punto',                                 'es': 'depurar'};
Blockly.Words['request_log_warn']                     = {'en': 'warning',                                         'de': 'warning',                                         'ru': 'warning',                                         'pt': 'Atenção',                                         'nl': 'waarschuwing',                                    'fr': 'Attention',                                       'it': 'avvertimento',                                    'es': 'advertencia'};
Blockly.Words['request_log_error']                    = {'en': 'error',                                           'de': 'error',                                           'ru': 'ошибка',                                          'pt': 'erro',                                            'nl': 'fout',                                            'fr': 'Erreur',                                          'it': 'errore',                                          'es': 'error'};

// --- CONVERT --------------------------------------------------
Blockly.Words['Convert']                              = {'en': 'Convert',                                         'de': 'Konvertierung',                                   'ru': 'Конвертация',                                     'pt': 'Converter',                                       'nl': 'Converteren',                                     'fr': 'Convertir',                                       'it': 'Convertire',                                      'es': 'Convertir'};

// --- convert convert --------------------------------------------------
Blockly.Words['convert_tonumber']                     = {'en': 'toNumber',                                        'de': 'nach Zahl',                                       'ru': 'в число',                                         'pt': 'enumerar',                                        'nl': 'toNumber',                                        'fr': 'toNumber',                                        'it': 'ToNumber',                                        'es': 'Al numero'};
Blockly.Words['convert_tonumber_tooltip']             = {'en': 'Cast input to number',                            'de': 'Wandle Eingang nach Zahl',                        'ru': 'Преобразовать вход в число',                      'pt': 'Transmitir entrada para o número',                'nl': 'Cast input naar nummer',                          'fr': 'Transmettre l\'entrée au numéro',                 'it': 'Trasmetti l\'input al numero',                    'es': 'Emitir entrada al número'};
Blockly.Words['convert_toboolean']                    = {'en': 'toBoolean',                                       'de': 'nach Logikwert',                                  'ru': 'в булево значение',                               'pt': 'toBoolean',                                       'nl': 'toBoolean',                                       'fr': 'toBooléen',                                       'it': 'toBoolean',                                       'es': 'toBoolean'};
Blockly.Words['convert_toboolean_tooltip']            = {'en': 'Cast input to boolean',                           'de': 'Wandle Input nach Logikwert',                     'ru': 'Преобразовать вход в булево значение',            'pt': 'Transmitir entrada para booleano',                'nl': 'Cast input naar boolean',                         'fr': 'Transmettre l\'entrée au booléen',                'it': 'Trasmetti l\'input a booleano',                   'es': 'Enviar entrada a boolean'};
Blockly.Words['convert_tostring']                     = {'en': 'toString',                                        'de': 'nach String',                                     'ru': 'в строку',                                        'pt': 'para sequenciar',                                 'nl': 'toString',                                        'fr': 'toString',                                        'it': 'accordare',                                       'es': 'Encadenar'};
Blockly.Words['convert_tostring_tooltip']             = {'en': 'Cast input to number',                            'de': 'Wandle Input nach String',                        'ru': 'Преобразовать вход в строку',                     'pt': 'Transmitir entrada para o número',                'nl': 'Cast input naar nummer',                          'fr': 'Transmettre l\'entrée au numéro',                 'it': 'Trasmetti l\'input al numero',                    'es': 'Emitir entrada al número'};
Blockly.Words['convert_type']                         = {'en': 'type of',                                         'de': 'Typ von',                                         'ru': 'взять тип',                                       'pt': 'tipo de',                                         'nl': 'soort van',                                       'fr': 'Type de',                                         'it': 'tipo di',                                         'es': 'tipo de'};
Blockly.Words['convert_type_tooltip']                 = {'en': 'Returns type of input',                           'de': 'Typ von Input',                                   'ru': 'Взять тип входа',                                 'pt': 'Retorna o tipo de entrada',                       'nl': 'Retourneert het type invoer',                     'fr': 'Renvoie le type d\'entrée',                       'it': 'Restituisce il tipo di input',                    'es': 'Devuelve tipo de entrada'};
Blockly.Words['convert_to_date']                      = {'en': 'to Date/Time',                                    'de': 'nach Datum/Zeit',                                 'ru': 'в дату/время',                                    'pt': 'até a data/hora',                                 'nl': 'tot datum/tijd',                                  'fr': 'à date/heure',                                    'it': 'alla data/ora',                                   'es': 'hasta la fecha/hora'};
Blockly.Words['convert_to_date_tooltip']              = {'en': 'Cast input to date',                              'de': 'Wandle Input nach Datum',                         'ru': 'Преобразовать вход в дату',                       'pt': 'Entrada em destaque até à data',                  'nl': 'Cast input tot op heden',                         'fr': 'Diffuser l\'entrée à ce jour',                    'it': 'Trasmetti l\'input fino alla data',               'es': 'Emitir entrada hasta la fecha'};
Blockly.Words['convert_from_date']                    = {'en': 'date/time',                                       'de': 'Datum/Zeit',                                      'ru': 'дату/время',                                      'pt': 'data hora',                                       'nl': 'datum Tijd',                                      'fr': 'date/heure',                                      'it': 'appuntamento',                                    'es': 'fecha y hora'};
Blockly.Words['convert_to']                           = {'en': 'to',                                              'de': 'nach',                                            'ru': 'в',                                               'pt': 'para',                                            'nl': 'naar',                                            'fr': 'à',                                               'it': 'a',                                               'es': 'a'};
Blockly.Words['convert_from_date_tooltip']            = {'en': 'Cast input from date',                            'de': 'erzeuge Input aus Datum',                         'ru': 'Преобразовать вход из даты',                      'pt': 'Entrada de elenco a partir da data',              'nl': 'Cast-invoer vanaf datum',                         'fr': 'Transmettre l\'entrée de la date',                'it': 'Trasmetti input dalla data',                      'es': 'Emitir entrada desde la fecha'};
Blockly.Words['convert_json2object']                  = {'en': 'JSON to object',                                  'de': 'JSON nach Objekt',                                'ru': 'JSON в объект',                                   'pt': 'JSON para objetar',                               'nl': 'JSON om bezwaar aan te tekenen',                  'fr': 'JSON à objet',                                    'it': 'JSON per obiettare',                              'es': 'JSON para objetar'};
Blockly.Words['convert_json2object_tooltip']          = {'en': 'Parse JSON string',                               'de': 'Parse JSON',                                      'ru': 'Преобразовать JSON в объект',                     'pt': 'Parse JSON string',                               'nl': 'Ontleed JSON-tekenreeks',                         'fr': 'Parse JSON chaîne',                               'it': 'Analizza la stringa JSON',                        'es': 'Cadena Parson JSON'};
Blockly.Words['convert_object2json']                  = {'en': 'object to JSON',                                  'de': 'Objekt nach JSON',                                'ru': 'объект в JSON',                                   'pt': 'Objeto para JSON',                                'nl': 'bezwaar tegen JSON',                              'fr': 'objet à JSON',                                    'it': 'oggetto a JSON',                                  'es': 'objetar a JSON'};
Blockly.Words['convert_object2json_tooltip']          = {'en': 'Strinify object',                                 'de': 'Objekt nach JSON',                                'ru': 'Преобразовать объект в JSON',                     'pt': 'Strinify objeto',                                 'nl': 'Strinify-object',                                 'fr': 'Strinify objet',                                  'it': 'Strinificare l\'oggetto',                         'es': 'Objeto Strinify'};
Blockly.Words['convert_object2json_prettify']         = {'en': 'prettify',                                        'de': 'formatieren',                                     'ru': 'форматировать',                                   'pt': 'embelezar',                                       'nl': 'leuk maken',                                      'fr': 'enjoliver',                                       'it': 'abbellire',                                       'es': 'embellecer'};

// --- SENDTO --------------------------------------------------
Blockly.Words['Sendto']                               = {'en': 'Sendto',                                          'de': 'Sendto',                                          'ru': 'Sendto',                                          'pt': 'Enviar para',                                     'nl': 'Verzenden naar',                                  'fr': 'Envoyer à',                                       'it': 'Inviare a',                                       'es': 'Enviar a'};

// --- sendto sendto --------------------------------------------------
Blockly.Words['sendto_message']                       = {'en': 'message',                                         'de': 'Meldung',                                         'ru': 'сообщение',                                       'pt': 'mensagem',                                        'nl': 'bericht',                                         'fr': 'message',                                         'it': 'Messaggio',                                       'es': 'mensaje'};
Blockly.Words['sendto_custom']                        = {'en': 'sendTo',                                          'de': 'sendTo',                                          'ru': 'sendTo',                                          'pt': 'enviar para',                                     'nl': 'verzenden naar',                                  'fr': 'envoyer à',                                       'it': 'inviare a',                                       'es': 'enviar a'};
Blockly.Words['sendto_custom_tooltip']                = {'en': 'Text to speech',                                  'de': 'Text zu Sprache',                                 'ru': 'Произнести сообщение',                            'pt': 'Texto para fala',                                 'nl': 'Tekst naar spraak',                               'fr': 'Texte pour parler',                               'it': 'Sintesi vocale',                                  'es': 'Texto a voz'};
Blockly.Words['sendto_custom_help']                   = {'en': 'sendto',                                          'de': 'sendto',                                          'ru': 'sendto',                                          'pt': 'enviar para',                                     'nl': 'verzenden naar',                                  'fr': 'envoyer à',                                       'it': 'inviare a',                                       'es': 'enviar a'};
Blockly.Words['sendto_custom_arguments']              = {'en': 'parameters',                                      'de': 'Parameter',                                       'ru': 'параметры',                                       'pt': 'parâmetros',                                      'nl': 'parameters',                                      'fr': 'paramètres',                                      'it': 'parametri',                                       'es': 'parámetros'};
Blockly.Words['sendto_custom_command']                = {'en': 'command',                                         'de': 'Befehl',                                          'ru': 'команда',                                         'pt': 'comando',                                         'nl': 'opdracht',                                        'fr': 'commander',                                       'it': 'comando',                                         'es': 'mando'};
Blockly.Words['sendto_custom_argument']               = {'en': 'parameter',                                       'de': 'Parameter',                                       'ru': 'параметр',                                        'pt': 'parâmetro',                                       'nl': 'parameter',                                       'fr': 'paramètre',                                       'it': 'parametro',                                       'es': 'parámetro'};
Blockly.Words['sendto_custom_arg_tooltip']            = {'en': 'Add parameter to sendTo object.',                 'de': 'Parameter zum sendTo-Objekt hinzufügen',          'ru': 'Добавить параметр к sendTo объекту',              'pt': 'Adicione o parâmetro ao objeto sendTo.',          'nl': 'Parameter toevoegen aan het object sendTo.',      'fr': 'Ajouter un paramètre à l\'objet sendTo.',         'it': 'Aggiungi parametro all\'oggetto sendTo.',         'es': 'Agregar parámetro al objeto sendTo.'};
Blockly.Words['sendto_log']                           = {'en': 'log level',                                       'de': 'Loglevel',                                        'ru': 'Протокол',                                        'pt': 'nível de log',                                    'nl': 'Log niveau',                                      'fr': 'niveau de journalisation',                        'it': 'livello di registro',                             'es': 'nivel de registro'};
Blockly.Words['sendto_log_none']                      = {'en': 'none',                                            'de': 'keins',                                           'ru': 'нет',                                             'pt': 'Nenhum',                                          'nl': 'geen',                                            'fr': 'aucun',                                           'it': 'nessuna',                                         'es': 'ninguna'};
Blockly.Words['sendto_log_info']                      = {'en': 'info',                                            'de': 'info',                                            'ru': 'инфо',                                            'pt': 'informação',                                      'nl': 'info',                                            'fr': 'Info',                                            'it': 'Informazioni',                                    'es': 'información'};
Blockly.Words['sendto_log_debug']                     = {'en': 'debug',                                           'de': 'debug',                                           'ru': 'debug',                                           'pt': 'depurar',                                         'nl': 'debug',                                           'fr': 'déboguer',                                        'it': 'mettere a punto',                                 'es': 'depurar'};
Blockly.Words['sendto_log_warn']                      = {'en': 'warning',                                         'de': 'warning',                                         'ru': 'warning',                                         'pt': 'Atenção',                                         'nl': 'waarschuwing',                                    'fr': 'Attention',                                       'it': 'avvertimento',                                    'es': 'advertencia'};
Blockly.Words['sendto_log_error']                     = {'en': 'error',                                           'de': 'error',                                           'ru': 'ошибка',                                          'pt': 'erro',                                            'nl': 'fout',                                            'fr': 'Erreur',                                          'it': 'errore',                                          'es': 'error'};

// --- SYSTEM --------------------------------------------------
Blockly.Words['System']                               = {'en': 'System',                                          'de': 'System',                                          'ru': 'Системные',                                       'pt': 'Sistema',                                         'nl': 'Systeem',                                         'fr': 'Système',                                         'it': 'Sistema',                                         'es': 'Sistema'};

// --- system debug --------------------------------------------------
Blockly.Words['debug']                                = {'en': 'debug output',                                    'de': 'debug output',                                    'ru': 'debug output',                                    'pt': 'saída de depuração',                              'nl': 'debug output',                                    'fr': 'sortie de débogage',                              'it': 'uscita di debug',                                 'es': 'salida de depuración'};
Blockly.Words['debug_tooltip']                        = {'en': 'Debug',                                           'de': 'Debug',                                           'ru': 'Debug',                                           'pt': 'Depurar',                                         'nl': 'debug',                                           'fr': 'Déboguer',                                        'it': 'mettere a punto',                                 'es': 'Depurar'};
Blockly.Words['debug_help']                           = {'en': 'log---gives-out-the-message-into-log',            'de': 'log---gives-out-the-message-into-log',            'ru': 'log---gives-out-the-message-into-log',            'pt': 'log---gives-out-the-message-into-log',            'nl': 'log---gives-out-the-message-into-log',            'fr': 'log---gives-out-the-message-into-log',            'it': 'log---gives-out-the-message-into-log',            'es': 'log---gives-out-the-message-into-log'};

// --- system comment --------------------------------------------------
Blockly.Words['comment']                              = {'en': 'comment',                                         'de': 'Kommentar',                                       'ru': 'описание',                                        'pt': 'Comente',                                         'nl': 'commentaar',                                      'fr': 'commentaire',                                     'it': 'commento',                                        'es': 'comentario'};
Blockly.Words['comment_tooltip']                      = {'en': 'Enter comment to explain the code',               'de': 'Debug',                                           'ru': 'Debug',                                           'pt': 'Digite o comentário para explicar o código',      'nl': 'Voer een opmerking in om de code uit te leggen',  'fr': 'Entrez un commentaire pour expliquer le code',    'it': 'Inserisci il commento per spiegare il codice',    'es': 'Ingrese un comentario para explicar el código'};

// --- system control --------------------------------------------------
Blockly.Words['control']                              = {'en': 'сontrol',                                         'de': 'steuere',                                         'ru': 'установить',                                      'pt': 'controlar',                                       'nl': 'сontrol',                                         'fr': 'contrôle',                                        'it': 'сontrol',                                         'es': 'ontrol'};
Blockly.Words['control_tooltip']                      = {'en': 'Control state',                                   'de': 'Steuere Zustand',                                 'ru': 'Установить состояние',                            'pt': 'Estado de controle',                              'nl': 'Controlestatus',                                  'fr': 'Etat de contrôle',                                'it': 'Stato di controllo',                              'es': 'Estado de control'};
Blockly.Words['control_help']                         = {'en': 'setstate',                                        'de': 'setstate',                                        'ru': 'setstate',                                        'pt': 'settate',                                         'nl': 'setstate',                                        'fr': 'setstate',                                        'it': 'setstate',                                        'es': 'setstate'};
Blockly.Words['control_with']                         = {'en': 'with',                                            'de': 'mit',                                             'ru': 'на',                                              'pt': 'com',                                             'nl': 'met',                                             'fr': 'avec',                                            'it': 'con',                                             'es': 'con'};
Blockly.Words['control_delay']                        = {'en': 'with delay',                                      'de': 'mit Verzögerung',                                 'ru': 'с задержкой',                                     'pt': 'com atraso',                                      'nl': 'met vertraging',                                  'fr': 'avec du retard',                                  'it': 'con ritardo',                                     'es': 'con retraso'};
Blockly.Words['control_ms']                           = {'en': 'ms',                                              'de': 'ms',                                              'ru': 'мс',                                              'pt': 'Senhora',                                         'nl': 'Mevrouw',                                         'fr': 'Mme',                                             'it': 'Signorina',                                       'es': 'Sra'};
Blockly.Words['control_sec']                          = {'en': 'sec',                                             'de': 'Sek',                                             'ru': 'сек.',                                            'pt': 'seg',                                             'nl': 'sec',                                             'fr': 'seconde',                                         'it': 'secondo',                                         'es': 'segundo'};
Blockly.Words['control_min']                          = {'en': 'min',                                             'de': 'Min',                                             'ru': 'мин.',                                            'pt': 'min',                                             'nl': 'min',                                             'fr': 'min',                                             'it': 'min',                                             'es': 'min'};
Blockly.Words['control_clear_running']                = {'en': ', clear running',                                 'de': ', löschen falls läuft',                           'ru': ', остановить уже запущенный',                     'pt': ', corrida clara',                                 'nl': ', helder rennen',                                 'fr': ', course libre',                                  'it': ', chiara corsa',                                  'es': ', claro funcionamiento'};

// --- system toggle --------------------------------------------------
Blockly.Words['toggle']                               = {'en': 'toggle',                                          'de': 'umschalten',                                      'ru': 'переключить',                                     'pt': 'alternancia',                                     'nl': 'toggle',                                          'fr': 'basculer',                                        'it': 'ginocchiera',                                     'es': 'palanca'};
Blockly.Words['toggle_tooltip']                       = {'en': 'Toggle the state',                                'de': 'Schalte Zustand um',                              'ru': 'Изменить состояние',                              'pt': 'Alternar o estado',                               'nl': 'Schakel de staat in',                             'fr': 'Basculer l\'état',                                'it': 'Attiva/disattiva lo stato',                       'es': 'Alternar el estado'};
Blockly.Words['toggle_help']                          = {'en': 'setstate',                                        'de': 'setstate',                                        'ru': 'setstate',                                        'pt': 'settate',                                         'nl': 'setstate',                                        'fr': 'setstate',                                        'it': 'setstate',                                        'es': 'setstate'};
Blockly.Words['toggle_with']                          = {'en': 'with',                                            'de': 'mit',                                             'ru': 'на',                                              'pt': 'com',                                             'nl': 'met',                                             'fr': 'avec',                                            'it': 'con',                                             'es': 'con'};
Blockly.Words['toggle_delay']                         = {'en': 'with delay',                                      'de': 'mit Verzögerung',                                 'ru': 'с задержкой',                                     'pt': 'com atraso',                                      'nl': 'met vertraging',                                  'fr': 'avec du retard',                                  'it': 'con ritardo',                                     'es': 'con retraso'};
Blockly.Words['toggle_ms']                            = {'en': 'in ms',                                           'de': 'in ms',                                           'ru': 'в мс',                                            'pt': 'em ms',                                           'nl': 'in ms',                                           'fr': 'en ms',                                           'it': 'in ms',                                           'es': 'en ms'};
Blockly.Words['toggle_clear_running']                 = {'en': ', clear running',                                 'de': ', löschen falls läuft',                           'ru': ', остановить уже запущенный',                     'pt': ', corrida clara',                                 'nl': ', helder rennen',                                 'fr': ', course libre',                                  'it': ', chiara corsa',                                  'es': ', claro funcionamiento'};

// --- system update --------------------------------------------------
Blockly.Words['update']                               = {'en': 'update',                                          'de': 'aktualisiere',                                    'ru': 'обновить',                                        'pt': 'atualizar',                                       'nl': 'bijwerken',                                       'fr': 'mettre à jour',                                   'it': 'aggiornare',                                      'es': 'actualizar'};
Blockly.Words['update_tooltip']                       = {'en': 'Update state',                                    'de': 'Zustand aktualisieren',                           'ru': 'Обновить состояние',                              'pt': 'Estado de atualização',                           'nl': 'Status bijwerken',                                'fr': 'Mettre à jour',                                   'it': 'Stato di aggiornamento',                          'es': 'Actualizar estado'};
Blockly.Words['update_help']                          = {'en': 'setstate',                                        'de': 'setstate',                                        'ru': 'setstate',                                        'pt': 'settate',                                         'nl': 'setstate',                                        'fr': 'setstate',                                        'it': 'setstate',                                        'es': 'setstate'};
Blockly.Words['update_with']                          = {'en': 'with',                                            'de': 'mit',                                             'ru': 'с',                                               'pt': 'com',                                             'nl': 'met',                                             'fr': 'avec',                                            'it': 'con',                                             'es': 'con'};
Blockly.Words['update_delay']                         = {'en': 'with delay',                                      'de': 'mit Verzögerung',                                 'ru': 'с задержкой',                                     'pt': 'com atraso',                                      'nl': 'met vertraging',                                  'fr': 'avec du retard',                                  'it': 'con ritardo',                                     'es': 'con retraso'};
Blockly.Words['update_ms']                            = {'en': 'in ms',                                           'de': 'in ms',                                           'ru': 'в мс',                                            'pt': 'em ms',                                           'nl': 'in ms',                                           'fr': 'en ms',                                           'it': 'in ms',                                           'es': 'en ms'};

// --- system direct --------------------------------------------------
Blockly.Words['direct']                               = {'en': 'bind',                                            'de': 'binde',                                           'ru': 'связять',                                         'pt': 'ligar',                                           'nl': 'binden',                                          'fr': 'lier',                                            'it': 'legare',                                          'es': 'enlazar'};
Blockly.Words['direct_tooltip']                       = {'en': 'Bind two states with each other',                 'de': 'Binde zwei Zustände miteinander',                 'ru': 'Связать два состояния между собой',               'pt': 'Vincule dois estados uns com os outros',          'nl': 'Bind twee toestanden met elkaar',                 'fr': 'Liez deux états l\'un à l\'autre',                'it': 'Associare due stati tra loro',                    'es': 'Enlazar dos estados entre sí'};
Blockly.Words['direct_help']                          = {'en': 'setstate',                                        'de': 'setstate',                                        'ru': 'setstate',                                        'pt': 'settate',                                         'nl': 'setstate',                                        'fr': 'setstate',                                        'it': 'setstate',                                        'es': 'setstate'};
Blockly.Words['direct_oid_src']                       = {'en': '',                                                'de': '',                                                'ru': '',                                                'pt': '',                                                'nl': '',                                                'fr': '',                                                'it': '',                                                'es': ''};
Blockly.Words['direct_only_changes']                  = {'en': 'only changes',                                    'de': 'nur Änderungen',                                  'ru': 'только изменения',                                'pt': 'apenas muda',                                     'nl': 'alleen veranderingen',                            'fr': 'seulement des changements',                       'it': 'solo cambiamenti',                                'es': 'solo cambios'};
Blockly.Words['direct_oid_dst']                       = {'en': 'with',                                            'de': 'mit',                                             'ru': 'c',                                               'pt': 'com',                                             'nl': 'met',                                             'fr': 'avec',                                            'it': 'con',                                             'es': 'con'};

// --- system control --------------------------------------------------
Blockly.Words['control_ex']                           = {'en': 'write',                                           'de': 'schreibe',                                        'ru': 'записать',                                        'pt': 'Escreva',                                         'nl': 'schrijven',                                       'fr': 'écrire',                                          'it': 'Scrivi',                                          'es': 'escribir'};
Blockly.Words['control_ex_tooltip']                   = {'en': 'Control state',                                   'de': 'Steuere Zustand',                                 'ru': 'Установить состояние',                            'pt': 'Estado de controle',                              'nl': 'Controlestatus',                                  'fr': 'Etat de contrôle',                                'it': 'Stato di controllo',                              'es': 'Estado de control'};
Blockly.Words['control_ex_control']                   = {'en': 'сontrol',                                         'de': 'steuere',                                         'ru': 'установить',                                      'pt': 'controlar',                                       'nl': 'сontrol',                                         'fr': 'contrôle',                                        'it': 'сontrol',                                         'es': 'ontrol'};
Blockly.Words['control_ex_update']                    = {'en': 'update',                                          'de': 'aktualisiere',                                    'ru': 'обновить',                                        'pt': 'atualizar',                                       'nl': 'bijwerken',                                       'fr': 'mettre à jour',                                   'it': 'aggiornare',                                      'es': 'actualizar'};
Blockly.Words['control_ex_delay']                     = {'en': 'delay in ms',                                     'de': 'Verzögerung in ms',                               'ru': 'Задержка в мс',                                   'pt': 'atraso em ms',                                    'nl': 'vertraging in ms',                                'fr': 'retarder en ms',                                  'it': 'ritardo in ms',                                   'es': 'retraso en ms'};
Blockly.Words['control_ex_value']                     = {'en': 'value',                                           'de': 'Wert',                                            'ru': 'значение',                                        'pt': 'valor',                                           'nl': 'waarde',                                          'fr': 'valeur',                                          'it': 'valore',                                          'es': 'valor'};
Blockly.Words['control_ex_clear_running']             = {'en': 'clear running',                                   'de': 'löschen falls läuft',                             'ru': 'остановить уже запущенный',                       'pt': 'corrida clara',                                   'nl': 'vrijlopen',                                       'fr': 'clair course',                                    'it': 'corsa libera',                                    'es': 'funcionamiento claro'};

// --- system create --------------------------------------------------
Blockly.Words['create']                               = {'en': 'create state',                                    'de': 'Zustand erzeugen',                                'ru': 'создать состояние',                               'pt': 'criar estado',                                    'nl': 'creëer staat',                                    'fr': 'créer un état',                                   'it': 'creare stato',                                    'es': 'crear estado'};
Blockly.Words['create_jsState']                       = {'en': 'jsState',                                         'de': 'jsState',                                         'ru': 'jsState',                                         'pt': 'jsState',                                         'nl': 'jsState',                                         'fr': 'jsState',                                         'it': 'jsState',                                         'es': 'jsState'};
Blockly.Words['create_tooltip']                       = {'en': 'create state',                                    'de': 'Zustand erzeugen',                                'ru': 'создать состояние',                               'pt': 'criar estado',                                    'nl': 'creëer staat',                                    'fr': 'créer un état',                                   'it': 'creare stato',                                    'es': 'crear estado'};
Blockly.Words['create_help']                          = {'en': 'createstate',                                     'de': 'createstate',                                     'ru': 'createstate',                                     'pt': 'criar',                                           'nl': 'createstate',                                     'fr': 'créature',                                        'it': 'createstate',                                     'es': 'crear estado'};

// --- system get --------------------------------------------------
Blockly.Words['get_value']                            = {'en': 'Get state value',                                 'de': 'Zustandswert nehmen',                             'ru': 'Взять значение состояния',                        'pt': 'Obter valor do estado',                           'nl': 'Krijg statuswaarde',                              'fr': 'Obtenir la valeur de l\'état',                    'it': 'Ottieni valore statale',                          'es': 'Obtener valor de estado'};
Blockly.Words['get_value_OID']                        = {'en': 'of Object ID',                                    'de': 'vom Objekt ID',                                   'ru': 'у объекта',                                       'pt': 'de ID do objeto',                                 'nl': 'van Object ID',                                   'fr': 'd\'identifiant d\'objet',                         'it': 'di ID oggetto',                                   'es': 'de Object ID'};
Blockly.Words['get_value_tooltip']                    = {'en': 'Select object ID with dialog',                    'de': 'Objekt ID mit Dialog selektieren',                'ru': 'Выбрать ID объекта',                              'pt': 'Selecione ID do objeto com diálogo',              'nl': 'Selecteer object-ID met dialoogvenster',          'fr': 'Sélectionnez l\'ID d\'objet avec la boîte de dialogue', 'it': 'Seleziona ID oggetto con finestra di dialogo',    'es': 'Seleccionar ID de objeto con diálogo'};
Blockly.Words['get_value_help']                       = {'en': 'getstate',                                        'de': 'getstate',                                        'ru': 'getstate',                                        'pt': 'obter',                                           'nl': 'getstate',                                        'fr': 'getstate',                                        'it': 'GetState',                                        'es': 'Gettate'};
Blockly.Words['get_value_default']                    = {'en': 'select ID',                                       'de': 'ID auswählen',                                    'ru': 'Выбрать ID',                                      'pt': 'selecione ID',                                    'nl': 'selecteer ID',                                    'fr': 'sélectionnez ID',                                 'it': 'seleziona ID',                                    'es': 'seleccionar ID'};
Blockly.Words['get_value_val']                        = {'en': 'Value',                                           'de': 'Wert',                                            'ru': 'Значение',                                        'pt': 'Valor',                                           'nl': 'Waarde',                                          'fr': 'Valeur',                                          'it': 'Valore',                                          'es': 'Valor'};
Blockly.Words['get_value_ack']                        = {'en': 'Acknowledge',                                     'de': 'anerkannt',                                       'ru': 'Подтверждение',                                   'pt': 'Reconhecer',                                      'nl': 'Erkennen',                                        'fr': 'Reconnaître',                                     'it': 'Riconoscere',                                     'es': 'Reconocer'};
Blockly.Words['get_value_ts']                         = {'en': 'Timestamp',                                       'de': 'Zeitstempel',                                     'ru': 'Время',                                           'pt': 'Timestamp',                                       'nl': 'tijdstempel',                                     'fr': 'Horodatage',                                      'it': 'timestamp',                                       'es': 'Marca de tiempo'};
Blockly.Words['get_value_lc']                         = {'en': 'Last change ',                                    'de': 'Letze Änderung',                                  'ru': 'Последнее изменеие',                              'pt': 'Última mudança',                                  'nl': 'Laatste wijziging',                               'fr': 'Dernier changement',                              'it': 'Ultima modifica',                                 'es': 'Ultimo cambio'};
Blockly.Words['get_value_q']                          = {'en': 'Quality',                                         'de': 'Qualität',                                        'ru': 'Качество',                                        'pt': 'Qualidade',                                       'nl': 'Kwaliteit',                                       'fr': 'Qualité',                                         'it': 'Qualità',                                         'es': 'Calidad'};
Blockly.Words['get_value_from']                       = {'en': 'Source',                                          'de': 'Quelle',                                          'ru': 'Происхождение',                                   'pt': 'Fonte',                                           'nl': 'Bron',                                            'fr': 'La source',                                       'it': 'fonte',                                           'es': 'Fuente'};
Blockly.Words['get_value_async']                      = {'en': 'Get state value',                                 'de': 'Zustandswert nehmen',                             'ru': 'Взять значение состояния',                        'pt': 'Obter valor do estado',                           'nl': 'Krijg statuswaarde',                              'fr': 'Obtenir la valeur de l\'état',                    'it': 'Ottieni valore statale',                          'es': 'Obtener valor de estado'};

// --- system field --------------------------------------------------
Blockly.Words['field_oid']                            = {'en': 'Select OID',                                      'de': 'Zustand erzeugen',                                'ru': 'создать состояние',                               'pt': 'Selecione OID',                                   'nl': 'Selecteer OID',                                   'fr': 'Sélectionnez OID',                                'it': 'Seleziona OID',                                   'es': 'Seleccionar OID'};
Blockly.Words['field_oid_OID']                        = {'en': 'Object ID',                                       'de': 'Objekt ID',                                       'ru': 'ID объекта',                                      'pt': 'ID do objeto',                                    'nl': 'Object ID',                                       'fr': 'ID de l\'objet',                                  'it': 'ID oggetto',                                      'es': 'ID del objeto'};
Blockly.Words['field_oid_tooltip']                    = {'en': 'Select object ID with dialog',                    'de': 'Objekt ID mit Dialog selektieren',                'ru': 'Выбрать ID объекта',                              'pt': 'Selecione ID do objeto com diálogo',              'nl': 'Selecteer object-ID met dialoogvenster',          'fr': 'Sélectionnez l\'ID d\'objet avec la boîte de dialogue', 'it': 'Seleziona ID oggetto con finestra di dialogo',    'es': 'Seleccionar ID de objeto con diálogo'};

// --- get attribute --------------------------------------------------
Blockly.Words['get_attr']                             = {
    "en": "Get attribute",
    "de": "Attribut erhalten",
    "ru": "Получить атрибут",
    "pt": "Obter atributo",
    "nl": "Attribuut ophalen",
    "fr": "Obtenir l'attribut",
    "it": "Ottieni attributo",
    "es": "Obtener atributo",
    "pl": "Uzyskaj atrybut"
};
Blockly.Words['get_attr_path']                        =  {
    "en": "Attribute",
    "de": "Attribut",
    "ru": "Атрибут",
    "pt": "Atributo",
    "nl": "Attribuut",
    "fr": "Attribut",
    "it": "Attributo",
    "es": "Atributo",
    "pl": "Atrybut"
};
Blockly.Words['get_attr_by']                          = {'en': 'of Object',                                       'de': 'vom Objekt',                                      'ru': 'у объекта',                                       'pt': 'do objeto',                                       'nl': 'van Object',                                      'fr': 'd\'objet',                                        'it': 'di oggetto',                                      'es': 'de Object'};
Blockly.Words['get_attr_tooltip']                     = {
    "en": "Get attribute of object or JSON by path, like: 'attr1.attr'",
    "de": "Erhalte Attribut des Objekts oder JSON nach Pfad, wie: 'attr1.attr'",
    "ru": "Получить атрибут объекта или JSON по пути, например: 'attr1.attr'",
    "pt": "Obter atributo de objeto ou JSON por caminho, como: 'attr1.attr'",
    "nl": "Krijg een attribuut van het object of JSON per pad, zoals: 'attr1.attr'",
    "fr": "Obtenir l'attribut d'objet ou JSON par chemin, comme: 'attr1.attr'",
    "it": "Ottieni attributo di oggetto o JSON per percorso, ad esempio: 'attr1.attr'",
    "es": "Obtenga el atributo de objeto o JSON por ruta, como: 'attr1.attr'",
    "pl": "Uzyskaj atrybut obiektu lub JSON według ścieżki, na przykład: \"attr1.attr\""
};
Blockly.Words['get_attr_help']                        = {'en': 'getattr', 'de': 'getattr', 'ru': 'getattr', 'pt': 'getattr', 'nl': 'getattr', 'fr': 'getattr', 'it': 'getattr', 'es': 'getattr'};

// --- text new line --------------------------------------------------
Blockly.Words['text_newline']                         = {'en': 'New line',                                        'de': 'Neue Zeile',                                      'ru': 'Новая строка',                                    'pt': 'Nova linha',                                      'nl': 'Nieuwe lijn',                                     'fr': 'Nouvelle ligne',                                  'it': 'Nuova linea',                                     'es': 'Nueva línea',                            'pl': 'Nowa linia'};
Blockly.Words['text_newline_tooltip']                 = {'en': 'Places new line in text',                         'de': 'Platziert eine neue Zeile im Text',               'ru': 'Размещение новой строки в тексте',                'pt': 'Coloca nova linha no texto',                      'nl': 'Plaatst nieuwe regel in tekst',                   'fr': 'Place une nouvelle ligne dans le texte',          'it': 'Inserisce una nuova riga nel testo',              'es': 'Coloca una nueva línea en el texto',     'pl': 'Umieszcza nową linię w tekście'};

// --- round to n digits ----------------------------------------------
Blockly.Words['math_rndfixed_round']                  = {'en': 'Round',                                           'de': 'Runde',                                           'ru': 'Раунд',                                           'pt': 'Arredondar',                                      'nl': 'Afronden',                                        'fr': 'Arrondir',                                        'it': 'Arrotondare',                                     'es': 'Redondea',                               'pl': 'Zaokrąglaj'};
Blockly.Words['math_rndfixed_to']                     = {'en': 'to',                                              'de': 'auf',                                             'ru': 'в',                                               'pt': 'para',                                            'nl': 'naar',                                            'fr': 'à',                                               'it': 'a',                                               'es': 'a',                                      'pl': 'do'};
Blockly.Words['math_rndfixed_decplcs']                = {'en': 'decimal places',                                  'de': 'Nachkommastellen',                                'ru': 'десятичные знаки',                                'pt': 'casas decimais',                                  'nl': 'plaatsen na de komma',                            'fr': 'décimales',                                       'it': 'decimali',                                        'es': 'lugares decimales',                      'pl': 'miejsca dziesiętne'};
Blockly.Words['math_rndfixed_tooltip']                = {'en': 'Rounds value to n decimal places',                'de': 'Rundet den Wert auf n Dezimalstellen',            'ru': 'Значение раундов до n знаков после запятой',      'pt': 'Arredonda o valor para n casas decimais',         'nl': 'Rondt waarde af naar n decimale plaatsen',        'fr': 'Arrondit la valeur à n décimales',                'it': 'Arrotonda il valore in n posizioni decimali',     'es': 'Redondea el valor a n lugares decimales','pl': 'Zaokrągla wartość do n miejsc po przecinku'};

// --- TIME --------------------------------------------------
Blockly.Words['Time']                                 = {'en': 'Date and Time',                                   'de': 'Datum und Zeit',                                  'ru': 'Дата и время',                                    'pt': 'Data e hora',                                     'nl': 'Datum en tijd',                                   'fr': 'Date et l\'heure',                                'it': 'Data e ora',                                      'es': 'Fecha y hora'};

// --- time time --------------------------------------------------
Blockly.Words['time_compare_ex']                      = {'en': 'Actual time',                                     'de': 'Aktuelle Zeit',                                   'ru': 'Текущее время',                                   'pt': 'Tempo real',                                      'nl': 'Werkelijke tijd',                                 'fr': 'Heure actuelle',                                  'it': 'Tempo reale',                                     'es': 'Tiempo actual'};
Blockly.Words['time_compare_custom_ex']               = {'en': 'Custom time',                                     'de': 'Zeit',                                            'ru': 'Время',                                           'pt': 'Tempo personalizado',                             'nl': 'Aangepaste tijd',                                 'fr': 'Temps personnalisé',                              'it': 'Tempo personalizzato',                            'es': 'Hora personalizada'};
Blockly.Words['time_compare_is_ex']                   = {'en': 'is',                                              'de': 'ist',                                             'ru': ' ',                                              'pt': 'é',                                               'nl': 'is',                                              'fr': 'est',                                             'it': 'è',                                               'es': 'es'};
Blockly.Words['time_compare_ex_custom']               = {'en': 'time',                                            'de': 'Zeit',                                            'ru': 'Время',                                           'pt': 'Tempo',                                           'nl': 'tijd',                                            'fr': 'temps',                                           'it': 'tempo',                                           'es': 'hora'};
Blockly.Words['time_compare_ex_tooltip']              = {'en': 'Compare time',                                    'de': 'Zeit vergleichen',                                'ru': 'Сравнить время',                                  'pt': 'Compare o tempo',                                 'nl': 'Vergelijk tijd',                                  'fr': 'Comparer le temps',                               'it': 'Confronta il tempo',                              'es': 'Compara el tiempo'};
Blockly.Words['time_compare_ex_help']                 = {'en': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'de': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'ru': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'pt': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'nl': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'fr': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'it': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'es': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md'};
Blockly.Words['time_compare']                         = {'en': 'Actual time is',                                  'de': 'Aktuelle Zeit ist',                               'ru': 'Время ',                                          'pt': 'O horário real é',                                'nl': 'De werkelijke tijd is',                           'fr': 'L\'heure actuelle est',                           'it': 'Il tempo reale è',                                'es': 'El tiempo real es'};
Blockly.Words['time_compare_tooltip']                 = {'en': 'Compare current time',                            'de': 'Vergleiche mit aktueller Zeit',                       'ru': 'Сравнить текущее время',                          'pt': 'Compare a hora atual',                            'nl': 'Vergelijk de huidige tijd',                       'fr': 'Comparer l\'heure actuelle',                      'it': 'Confronta l\'ora corrente',                       'es': 'Compara la hora actual'};
Blockly.Words['time_compare_help']                    = {'en': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'de': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'ru': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'pt': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'nl': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'fr': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'it': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'es': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md'};
Blockly.Words['time_compare_lt']                      = {'en': 'less than',                                       'de': 'kleiner als',                                     'ru': 'меньше чем',                                      'pt': 'menos que',                                       'nl': 'minder dan',                                      'fr': 'moins que',                                       'it': 'meno di',                                         'es': 'menos que'};
Blockly.Words['time_compare_le']                      = {'en': 'equal to or less than',                           'de': 'gleich oder kleiner als',                         'ru': 'равно или меньше чем',                            'pt': 'igual ou inferior a',                             'nl': 'gelijk aan of minder dan',                        'fr': 'égal ou inférieur à',                             'it': 'uguale o inferiore a',                            'es': 'igual o menor que'};
Blockly.Words['time_compare_gt']                      = {'en': 'greater than',                                    'de': 'größer als',                                      'ru': 'больше чем',                                      'pt': 'Melhor que',                                      'nl': 'groter dan',                                      'fr': 'plus grand que',                                  'it': 'più grande di',                                   'es': 'mas grande que'};
Blockly.Words['time_compare_ge']                      = {'en': 'equal to or greater than',                        'de': 'gleich oder größer als',                          'ru': 'равно или больше чем',                            'pt': 'igual ou maior do que',                           'nl': 'gelijk aan of groter dan',                        'fr': 'égal ou supérieur à',                             'it': 'uguale o maggiore di',                            'es': 'igual o mayor que'};
Blockly.Words['time_compare_eq']                      = {'en': 'equal to',                                        'de': 'gleich mit',                                      'ru': 'равно',                                           'pt': 'igual a',                                         'nl': 'gelijk aan',                                      'fr': 'égal à',                                          'it': 'uguale a',                                        'es': 'igual a'};
Blockly.Words['time_compare_bw']                      = {'en': 'between',                                         'de': 'zwischen',                                        'ru': 'между',                                           'pt': 'entre',                                           'nl': 'tussen',                                          'fr': 'entre',                                           'it': 'fra',                                             'es': 'Entre'};
Blockly.Words['time_compare_nb']                      = {'en': 'not between',                                     'de': 'nicht zwischen',                                  'ru': 'не между',                                        'pt': 'não entre',                                       'nl': 'niet tussen',                                     'fr': 'pas entre',                                       'it': 'non in mezzo',                                    'es': 'no entre'};
Blockly.Words['time_compare_and']                     = {'en': 'and',                                             'de': 'und',                                             'ru': 'и',                                               'pt': 'e',                                               'nl': 'en',                                              'fr': 'et',                                              'it': 'e',                                               'es': 'y'};
Blockly.Words['time_get']                             = {'en': 'Actual time as',                                  'de': 'Aktuelle Zeit als',                               'ru': 'Время ',                                          'pt': 'Tempo real como',                                 'nl': 'Werkelijke tijd als',                             'fr': 'Heure réelle sous',                               'it': 'Tempo reale come',                                'es': 'Tiempo real como'};
Blockly.Words['time_get_default_format']              = {'en': 'YYYY.MM.DD hh:mm:ss.sss',                         'de': 'JJJJ.MM.TT SS:mm:ss.sss',                         'ru': 'ГГГГ.ММ.ДД чч:мм:сс.ссс',                         'pt': 'AAAA.MM.DD hh: mm: ss.sss',                       'nl': 'JJJJ.MM.DD uu: mm: ss.sss',                       'fr': 'YYYY.MM.DD hh: mm: ss.sss',                       'it': 'YYYY.MM.DD hh: mm: ss.sss',                       'es': 'YYYY.MM.DD hh: mm: ss.sss'};
Blockly.Words['time_get_anyInstance']                 = {'en': 'all instances',                                   'de': 'Alle Instanzen',                                  'ru': 'На все драйвера',                                 'pt': 'todas as instâncias',                             'nl': 'alle instanties',                                 'fr': 'toutes les instances',                            'it': 'tutte le istanze',                                'es': 'todas las instancias'};
Blockly.Words['time_get_tooltip']                     = {'en': 'Send message to telegram',                        'de': 'Sende eine Meldung über Telegram',                'ru': 'Послать сообщение через Telegram',                'pt': 'Enviar mensagem para telegrama',                  'nl': 'Stuur bericht naar telegram',                     'fr': 'Envoyer un message au télégramme',                'it': 'Invia un messaggio al telegramma',                'es': 'Enviar mensaje a telegrama'};
Blockly.Words['time_get_help']                        = {'en': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'de': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'ru': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'pt': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'nl': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'fr': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'it': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'es': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md'};
Blockly.Words['time_get_object']                      = {'en': 'Date object',                                     'de': 'Datum-Objekt',                                    'ru': 'как объект',                                      'pt': 'Data objeto',                                     'nl': 'Datum object',                                    'fr': 'Objet de date',                                   'it': 'Data oggetto',                                    'es': 'Objeto de fecha'};
Blockly.Words['time_get_ms']                          = {'en': 'milliseconds',                                    'de': 'Millisekunden',                                   'ru': 'миллисекунды',                                    'pt': 'milissegundos',                                   'nl': 'milliseconden',                                   'fr': 'millisecondes',                                   'it': 'millisecondi',                                    'es': 'milisegundos'};
Blockly.Words['time_get_s']                           = {'en': 'seconds',                                         'de': 'Sekunden',                                        'ru': 'секунды',                                         'pt': 'segundos',                                        'nl': 'seconden',                                        'fr': 'secondes',                                        'it': 'secondi',                                         'es': 'segundos'};
Blockly.Words['time_get_m']                           = {'en': 'minutes',                                         'de': 'Minuten',                                         'ru': 'минуты',                                          'pt': 'minutos',                                         'nl': 'notulen',                                         'fr': 'minutes',                                         'it': 'minuti',                                          'es': 'minutos'};
Blockly.Words['time_get_mid']                         = {'en': 'minutes in day',                                  'de': 'Minuten seit Tagsanfang',                         'ru': 'кол-во минут с начала дня',                       'pt': 'minutos do dia',                                  'nl': 'minuten in dag',                                  'fr': 'minutes dans la journée',                         'it': 'minuti al giorno',                                'es': 'minutos en el día'};
Blockly.Words['time_get_sid']                         = {'en': 'seconds in day',                                  'de': 'Sekunden seit Tagsanfang',                        'ru': 'кол-во секунд с начала дня',                      'pt': 'segundos no dia',                                 'nl': 'seconden in dag',                                 'fr': 'secondes dans la journée',                        'it': 'secondi nel giorno',                              'es': 'segundos en el día'};
Blockly.Words['time_get_h']                           = {'en': 'hours',                                           'de': 'Stunden',                                         'ru': 'часы',                                            'pt': 'horas',                                           'nl': 'uur',                                             'fr': 'heures',                                          'it': 'ore',                                             'es': 'horas'};
Blockly.Words['time_get_d']                           = {'en': 'day of month',                                    'de': 'Monatsdatum',                                     'ru': 'день месяца',                                     'pt': 'dia do mês',                                      'nl': 'dag van de maand',                                'fr': 'jour du mois',                                    'it': 'giorno del mese',                                 'es': 'dia del mes'};
Blockly.Words['time_get_M']                           = {'en': 'month as number',                                 'de': 'Monat als Nummer',                                'ru': 'месяц числом',                                    'pt': 'mês como número',                                 'nl': 'maand als nummer',                                'fr': 'mois en nombre',                                  'it': 'mese come numero',                                'es': 'mes como número'};
Blockly.Words['time_get_Mt']                          = {'en': 'month as text',                                   'de': 'Monat als Text',                                  'ru': 'месяц словом',                                    'pt': 'mês como texto',                                  'nl': 'maand als tekst',                                 'fr': 'mois comme texte',                                'it': 'mese come testo',                                 'es': 'mes como texto'};
Blockly.Words['time_get_Mts']                         = {'en': 'month as short text',                             'de': 'Monat als Kurztext',                              'ru': 'месяц коротким словом',                           'pt': 'mês como texto curto',                            'nl': 'maand als korte tekst',                           'fr': 'mois comme texte court',                          'it': 'mese come breve testo',                           'es': 'mes como texto corto'};
Blockly.Words['time_get_y']                           = {'en': 'short year',                                      'de': 'Jahr, kurz',                                      'ru': 'короткий год',                                    'pt': 'ano curto',                                       'nl': 'kort jaar',                                       'fr': 'année courte',                                    'it': 'breve anno',                                      'es': 'año corto'};
Blockly.Words['time_get_fy']                          = {'en': 'full year',                                       'de': 'Jahr, voll',                                      'ru': 'полный год',                                      'pt': 'ano completo',                                    'nl': 'Volledig jaar',                                   'fr': 'année complète',                                  'it': 'anno pieno',                                      'es': 'Año completo'};
Blockly.Words['time_get_wdt']                         = {'en': 'week day text',                                   'de': 'Wochentag als Text',                              'ru': 'день недели словом',                              'pt': 'texto do dia da semana',                          'nl': 'weekdag tekst',                                   'fr': 'texte de la semaine',                             'it': 'testo del giorno della settimana',                'es': 'texto del día de la semana'};
Blockly.Words['time_get_wdts']                        = {'en': 'short week day',                                  'de': 'Wochentag als Kurztext',                          'ru': 'короткий день недели',                            'pt': 'dia da semana curto',                             'nl': 'korte weekdag',                                   'fr': 'jour de la semaine courte',                       'it': 'breve giorno della settimana',                    'es': 'día corto de la semana'};
Blockly.Words['time_get_wd']                          = {'en': 'week day as number',                              'de': 'Wochentag als Nummer',                            'ru': 'день недели числом',                              'pt': 'dia da semana como número',                       'nl': 'weekdag als nummer',                              'fr': 'jour de la semaine en nombre',                    'it': 'giorno della settimana come numero',              'es': 'día de la semana como número'};
Blockly.Words['time_get_custom']                      = {'en': 'custom format',                                   'de': 'anwenderformatiert',                              'ru': 'произвольный формат',                             'pt': 'formato personalizado',                           'nl': 'aangepast formaat',                               'fr': 'format personnalisé',                             'it': 'formato personalizzato',                          'es': 'formato personalizado'};
Blockly.Words['time_get_yyyy.mm.dd']                  = {'en': 'yyyy.mm.dd',                                      'de': 'JJJJ.MM.TT',                                      'ru': 'ГГГГ.ММ.ДД',                                      'pt': 'aaaa.mm.dd',                                      'nl': 'jjjj.mm.dd',                                      'fr': 'aaaa.mm.jj',                                      'it': 'yyyy.MM.dd',                                      'es': 'aaaa.mm.dd'};
Blockly.Words['time_get_yyyy/mm/dd']                  = {'en': 'yyyy/mm/dd',                                      'de': 'JJJJ/MM/TT',                                      'ru': 'ГГГГ/ММ/ДД',                                      'pt': 'aaaa/mm/dd',                                      'nl': 'yyyy/mm/dd',                                      'fr': 'aaaa/mm/jj',                                      'it': 'aaaa/mm/gg',                                      'es': 'aaaa/mm/dd'};
Blockly.Words['time_get_yy.mm.dd']                    = {'en': 'yy.mm.dd',                                        'de': 'JJ.MM.TT',                                        'ru': 'ГГ.ММ.ДД',                                        'pt': 'yy.mm.dd',                                        'nl': 'JJ.MM.DD',                                        'fr': 'yy.mm.dd',                                        'it': 'yy.mm.dd',                                        'es': 'yy.mm.dd'};
Blockly.Words['time_get_yy/mm/dd']                    = {'en': 'yy/mm/dd',                                        'de': 'JJ/MM/TT',                                        'ru': 'ГГ/ММ/ДД',                                        'pt': 'aa/mm/dd',                                        'nl': 'yy/mm/dd',                                        'fr': 'aa/mm/jj',                                        'it': 'aa/mm/dd',                                        'es': 'aa/mm/dd'};
Blockly.Words['time_get_dd.mm.yyyy']                  = {'en': 'dd.mm.yyyy',                                      'de': 'TT.MM.JJJJ',                                      'ru': 'ДД.ММ.ГГГГ',                                      'pt': 'dd.mm.yyyy',                                      'nl': 'dd.mm.yyyy',                                      'fr': 'jj.mm.aaaa',                                      'it': 'gg.mm.aaaa',                                      'es': 'dd.mm.yyyy'};
Blockly.Words['time_get_dd/mm/yyyy']                  = {'en': 'dd/mm/yyyy',                                      'de': 'TT/MM/JJJJ',                                      'ru': 'ДД/ММ/ГГГГ',                                      'pt': 'dd/mm/aaaa',                                      'nl': 'dd/mm/yyyy',                                      'fr': 'jj/mm/aaaa',                                      'it': 'gg/mm/aaaa',                                      'es': 'dd/mm/aaaa'};
Blockly.Words['time_get_dd.mm.yy']                    = {'en': 'dd.mm.yy',                                        'de': 'TT.MM.JJ',                                        'ru': 'ДД.ММ.ГГ',                                        'pt': 'dd.mm.yy',                                        'nl': 'dd.mm.jj',                                        'fr': 'jj.mm.aa',                                        'it': 'dd.mm.yy',                                        'es': 'dd.mm.yy'};
Blockly.Words['time_get_dd/mm/yy']                    = {'en': 'dd/mm/yy',                                        'de': 'TT/MM/JJ',                                        'ru': 'ДД/ММ/ГГ',                                        'pt': 'dd/mm/aa',                                        'nl': 'dd/mm/jj',                                        'fr': 'jj/mm/aa',                                        'it': 'gg/mm/aa',                                        'es': 'dd/mm/aa'};
Blockly.Words['time_get_mm/dd/yyyy']                  = {'en': 'mm/dd/yyyy',                                      'de': 'MM/TT/JJJJ',                                      'ru': 'ММ/ДД/ГГГГ',                                      'pt': 'mm/dd/aaaa',                                      'nl': 'mm/dd/yyyy',                                      'fr': 'mm/jj/aaaa',                                      'it': 'mm/gg/aaaa',                                      'es': 'mm/dd/aaaa'};
Blockly.Words['time_get_mm/dd/yy']                    = {'en': 'mm/dd/yy',                                        'de': 'MM/TT/JJ',                                        'ru': 'ММ/ДД/yy',                                        'pt': 'mm/dd/aaa',                                       'nl': 'MM/DD/JJ',                                        'fr': 'mm/jj/aa',                                        'it': 'mm/gg/aa',                                        'es': 'mm/dd/aa'};
Blockly.Words['time_get_dd.mm']                       = {'en': 'dd.mm.',                                          'de': 'TT.MM.',                                          'ru': 'ДД.ММ.',                                          'pt': 'dd.mm.',                                          'nl': 'DD.MM.',                                          'fr': 'jj.mm.',                                          'it': 'GG.MM.',                                          'es': 'dd.mm.'};
Blockly.Words['time_get_dd/mm']                       = {'en': 'dd/mm',                                           'de': 'TT/MM',                                           'ru': 'ДД/ММ',                                           'pt': 'dd/mm',                                           'nl': 'dd/mm',                                           'fr': 'jj/mm',                                           'it': 'gg/mm',                                           'es': 'dd/mm'};
Blockly.Words['time_get_mm.dd']                       = {'en': 'mm.dd',                                           'de': 'MM.TT',                                           'ru': 'ММ.ДД',                                           'pt': 'mm.dd',                                           'nl': 'mm.dd',                                           'fr': 'mm.dd',                                           'it': 'mm.dd',                                           'es': 'mm.dd'};
Blockly.Words['time_get_mm/dd']                       = {'en': 'mm/dd',                                           'de': 'MM/TT',                                           'ru': 'ММ/ДД',                                           'pt': 'mm/dd',                                           'nl': 'MM/DD',                                           'fr': 'mm/jj',                                           'it': 'mm/gg',                                           'es': 'mm/dd'};
Blockly.Words['time_get_hh_mm']                       = {'en': 'hh:mm',                                           'de': 'SS:mm',                                           'ru': 'чч:мм',                                           'pt': 'hh:mm',                                           'nl': 'hh:mm',                                           'fr': 'hh:mm',                                           'it': 'hh:mm',                                           'es': 'hh: mm'};
Blockly.Words['time_get_hh_mm_ss']                    = {'en': 'hh:mm:ss',                                        'de': 'SS:mm:ss',                                        'ru': 'чч:мм:сс',                                        'pt': 'hh:mm:ss',                                        'nl': 'hh:mm:ss',                                        'fr': 'hh:mm:ss',                                        'it': 'hh:mm:ss',                                        'es': 'hh: mm: ss'};
Blockly.Words['time_get_hh_mm_ss.sss']                = {'en': 'hh:mm:ss.sss',                                    'de': 'SS:mm:ss.sss',                                    'ru': 'чч:мм:сс.ссс',                                    'pt': 'hh:mm:ss.sss',                                    'nl': 'hh:mm:ss.sss',                                    'fr': 'hh:mm:ss.sss',                                    'it': 'hh:mm:ss.sss',                                    'es': 'hh: mm: ss.sss'};
Blockly.Words['time_astro']                           = {'en': 'Actual time of',                                  'de': 'Aktuelle Zeit von',                               'ru': 'Время ',                                          'pt': 'Tempo real de',                                   'nl': 'Huidige tijd van',                                'fr': 'Heure réelle de',                                 'it': 'Tempo reale di',                                  'es': 'Tiempo real de'};
Blockly.Words['time_astro_offset']                    = {'en': 'Offset (minutes)',                                'de': 'Offset (Minuten)',                                'ru': 'Сдвиг в минутах ',                                'pt': 'Offset (minutos)',                                'nl': 'Offset (minuten)',                                'fr': 'Décalage (minutes)',                              'it': 'Offset (minuti)',                                 'es': 'Desplazamiento (minutos)'};
Blockly.Words['time_astro_default_format']            = {'en': 'YYYY.MM.DD hh:mm:ss.sss',                         'de': 'JJJJ.MM.TT SS:mm:ss.sss',                         'ru': 'ГГГГ.ММ.ДД чч:мм:сс.ссс',                         'pt': 'AAAA.MM.DD hh:mm:ss.sss',                         'nl': 'JJJJ.MM.DD uu:mm:ss.sss',                         'fr': 'YYYY.MM.DD hh:mm:ss.sss',                         'it': 'YYYY.MM.DD hh:mm:ss.sss',                         'es': 'YYYY.MM.DD hh: mm: ss.sss'};
Blockly.Words['time_astro_tooltip']                   = {'en': 'Get actual time or ',                             'de': 'Sende eine Meldung über Telegram',                'ru': 'Послать сообщение через Telegram',                'pt': 'Receba o tempo real ou',                          'nl': 'Krijg actuele tijd of',                           'fr': 'Obtenez le temps réel ou',                        'it': 'Ottieni tempo reale o',                           'es': 'Obtenga tiempo real o'};
Blockly.Words['time_astro_help']                      = {'en': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'de': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'ru': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'pt': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'nl': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'fr': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'it': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md', 'es': 'https://git.spacen.net/yunkong2/yunkong2.telegram/blob/master/README.md'};

// --- TIMEOUTS --------------------------------------------------
Blockly.Words['Timeouts']                             = {'en': 'Timeouts',                                        'de': 'Timeouts',                                        'ru': 'Timeouts',                                        'pt': 'Tempo limite',                                    'nl': 'Time-outs',                                       'fr': 'Délais',                                          'it': 'Timeout',                                         'es': 'Tiempos de espera'};

// --- timeouts timeouts --------------------------------------------------
Blockly.Words['timeouts_settimeout']                  = {'en': 'Execution',                                       'de': 'Ausführen',                                       'ru': 'Выполнить',                                       'pt': 'Execução',                                        'nl': 'Executie',                                        'fr': 'Exécution',                                       'it': 'Esecuzione',                                      'es': 'Ejecución'};
Blockly.Words['timeouts_settimeout_name']             = {'en': 'timeout',                                         'de': 'Verzögerung',                                     'ru': 'Пауза',                                           'pt': 'tempo esgotado',                                  'nl': 'time-out',                                        'fr': 'temps libre',                                     'it': 'tempo scaduto',                                   'es': 'se acabó el tiempo'};
Blockly.Words['timeouts_settimeout_in']               = {'en': 'in',                                              'de': 'in',                                              'ru': 'через',                                           'pt': 'dentro',                                          'nl': 'in',                                              'fr': 'dans',                                            'it': 'in',                                              'es': 'en'};
Blockly.Words['timeouts_settimeout_ms']               = {'en': 'ms',                                              'de': 'ms',                                              'ru': 'мс',                                              'pt': 'Senhora',                                         'nl': 'Mevrouw',                                         'fr': 'Mme',                                             'it': 'Signorina',                                       'es': 'Sra'};
Blockly.Words['timeouts_settimeout_sec']              = {'en': 'sec',                                             'de': 'Sek',                                             'ru': 'сек.',                                            'pt': 'seg',                                             'nl': 'sec',                                             'fr': 'seconde',                                         'it': 'secondo',                                         'es': 'segundo'};
Blockly.Words['timeouts_settimeout_min']              = {'en': 'min',                                             'de': 'Min',                                             'ru': 'мин.',                                            'pt': 'min',                                             'nl': 'min',                                             'fr': 'min',                                             'it': 'min',                                             'es': 'min'};
Blockly.Words['timeouts_settimeout_tooltip']          = {'en': 'Delay execution',                                 'de': 'Ausführung verzögern',                            'ru': 'Сделать паузу',                                   'pt': 'Atrasar a execução',                              'nl': 'Vertraag uitvoering',                             'fr': 'Retarder l\'exécution',                           'it': 'Ritardare l\'esecuzione',                         'es': 'Demora de ejecución'};
Blockly.Words['timeouts_settimeout_help']             = {'en': 'settimeout',                                      'de': 'settimeout',                                      'ru': 'settimeout',                                      'pt': 'settimeout',                                      'nl': 'setTimeout',                                      'fr': 'settimeout',                                      'it': 'setTimeout',                                      'es': 'settimeout'};
Blockly.Words['timeouts_cleartimeout']                = {'en': 'clear',                                           'de': 'stop',                                            'ru': 'остановить',                                      'pt': 'Claro',                                           'nl': 'duidelijk',                                       'fr': 'clair',                                           'it': 'chiaro',                                          'es': 'claro'};
Blockly.Words['timeouts_cleartimeout_tooltip']        = {'en': 'Clear delay execution',                           'de': 'Ausführungsverzögerung anhalten',                 'ru': 'Отменить выполнение с паузой',                    'pt': 'Execução de atraso clara',                        'nl': 'Duidelijke uitvoering van vertragingen',          'fr': 'Effacer l\'exécution du délai',                   'it': 'Cancella l\'esecuzione del ritardo',              'es': 'Ejecución de retraso claro'};
Blockly.Words['timeouts_cleartimeout_help']           = {'en': 'cleartimeout',                                    'de': 'cleartimeout',                                    'ru': 'cleartimeout',                                    'pt': 'cleartimeout',                                    'nl': 'clearTimeout',                                    'fr': 'cleartimeout',                                    'it': 'clearTimeout',                                    'es': 'cleartimeout'};
Blockly.Words['timeouts_setinterval']                 = {'en': 'Execution',                                       'de': 'Ausführen',                                       'ru': 'Выполнить',                                       'pt': 'Execução',                                        'nl': 'Executie',                                        'fr': 'Exécution',                                       'it': 'Esecuzione',                                      'es': 'Ejecución'};
Blockly.Words['timeouts_setinterval_name']            = {'en': 'interval',                                        'de': 'Intervall',                                       'ru': 'интервал',                                        'pt': 'intervalo',                                       'nl': 'interval',                                        'fr': 'intervalle',                                      'it': 'intervallo',                                      'es': 'intervalo'};
Blockly.Words['timeouts_setinterval_in']              = {'en': 'every',                                           'de': 'alle',                                            'ru': 'каждые',                                          'pt': 'cada',                                            'nl': 'elk',                                             'fr': 'chaque',                                          'it': 'ogni',                                            'es': 'cada'};
Blockly.Words['timeouts_setinterval_ms']              = {'en': 'ms',                                              'de': 'ms',                                              'ru': 'мс',                                              'pt': 'Senhora',                                         'nl': 'Mevrouw',                                         'fr': 'Mme',                                             'it': 'Signorina',                                       'es': 'Sra'};
Blockly.Words['timeouts_setinterval_tooltip']         = {'en': 'Cyclic execution',                                'de': 'Zyklische Ausführung',                            'ru': 'Выполнять постоянно через интервал',              'pt': 'Execução cíclica',                                'nl': 'Cyclische uitvoering',                            'fr': 'Exécution cyclique',                              'it': 'Esecuzione ciclica',                              'es': 'Ejecución cíclica'};
Blockly.Words['timeouts_setinterval_help']            = {'en': 'setinterval',                                     'de': 'setinterval',                                     'ru': 'setinterval',                                     'pt': 'setinterval',                                     'nl': 'setInterval',                                     'fr': 'setinterval',                                     'it': 'setInterval',                                     'es': 'setinterval'};
Blockly.Words['timeouts_clearinterval']               = {'en': 'clear interval',                                  'de': 'stop zyklische Ausführung',                       'ru': 'остановить постоянное выполнение',                'pt': 'intervalo claro',                                 'nl': 'interval wissen',                                 'fr': 'intervalle clair',                                'it': 'intervallo chiaro',                               'es': 'intervalo claro'};
Blockly.Words['timeouts_clearinterval_tooltip']       = {'en': 'Clear interval execution',                        'de': 'Ausführungsintervall anhalten',                   'ru': 'Отменить цикличное выполнение с интервалом',      'pt': 'Execução de intervalo claro',                     'nl': 'Interval-uitvoering wissen',                      'fr': 'Effacer l\'intervalle d\'exécution',              'it': 'Cancella l\'esecuzione dell\'intervallo',         'es': 'Ejecución de intervalo claro'};
Blockly.Words['timeouts_clearinterval_help']          = {'en': 'clearinterval',                                   'de': 'clearinterval',                                   'ru': 'clearinterval',                                   'pt': 'clearinterval',                                   'nl': 'clearInterval',                                   'fr': 'clearinterval',                                   'it': 'clearInterval',                                   'es': 'clearinterval'};

// --- TRIGGER --------------------------------------------------
Blockly.Words['Trigger']                              = {'en': 'Trigger',                                         'de': 'Trigger',                                         'ru': 'События',                                         'pt': 'Desencadear',                                     'nl': 'In gang zetten',                                  'fr': 'Déclencheur',                                     'it': 'Grilletto',                                       'es': 'Desencadenar'};

// --- trigger on --------------------------------------------------
Blockly.Words['on_onchange']                          = {'en': 'was changed',                                     'de': 'wurde geändert',                                  'ru': 'изменился',                                       'pt': 'foi alterado',                                    'nl': 'was veranderd',                                   'fr': 'a été changé',                                    'it': 'era cambiato',                                    'es': 'fue cambiado'};
Blockly.Words['on_any']                               = {'en': 'was updated',                                     'de': 'wurde aktualisiert',                              'ru': 'обновился',                                       'pt': 'foi atualizado',                                  'nl': 'is geupdated',                                    'fr': 'a été mis à jour',                                'it': 'è stato aggiornato',                              'es': 'fue actualizado'};
Blockly.Words['on_gt']                                = {'en': 'is greater than last',                            'de': 'ist größer als letztes',                          'ru': 'больше прошлого',                                 'pt': 'é maior do que o último',                         'nl': 'is groter dan de vorige',                         'fr': 'est plus grand que le dernier',                   'it': 'è più grande dell\'ultimo',                       'es': 'es mayor que el último'};
Blockly.Words['on_ge']                                = {'en': 'is greater or equal than last',                   'de': 'ist gleich oder größer als letztes',              'ru': 'больше или равен прошлому',                       'pt': 'é maior ou igual que a última',                   'nl': 'is groter of gelijk dan de vorige',               'fr': 'est supérieur ou égal à la dernière',             'it': 'è maggiore o uguale alla precedente',             'es': 'es mayor o igual que el último'};
Blockly.Words['on_lt']                                = {'en': 'is less than last',                               'de': 'ist kleiner als letztes',                         'ru': 'меньше прошлого',                                 'pt': 'é menos do que o último',                         'nl': 'is minder dan de vorige',                         'fr': 'est moins que la dernière',                       'it': 'è inferiore all\'ultima',                         'es': 'es menos que el último'};
Blockly.Words['on_le']                                = {'en': 'is less or equal than last',                      'de': 'ist gleich oder kleiner als letztes',             'ru': 'меньше или равен прошлому',                       'pt': 'é menor ou igual que a última',                   'nl': 'is minder of gelijk dan de vorige',               'fr': 'est inférieur ou égal à la dernière',             'it': 'è inferiore o uguale all\'ultima',                'es': 'es menor o igual que el último'};
Blockly.Words['on_eq']                                = {'en': 'is same as last',                                 'de': 'ist gleich wie letztes',                          'ru': 'равен прошлому',                                  'pt': 'é o mesmo que o último',                          'nl': 'is hetzelfde als het laatst',                     'fr': 'est le même que le dernier',                      'it': 'è lo stesso dell\'ultimo',                        'es': 'es lo mismo que el último'};
Blockly.Words['on_true']                              = {'en': 'is true',                                         'de': 'ist wahr',                                        'ru': 'равен true',                                      'pt': 'é verdade',                                       'nl': 'is waar',                                         'fr': 'est vrai',                                        'it': 'è vero',                                          'es': 'es verdad'};
Blockly.Words['on_false']                             = {'en': 'is false',                                        'de': 'ist unwahr',                                      'ru': 'равен false',                                     'pt': 'é falso',                                         'nl': 'is fout',                                         'fr': 'c\'est faux',                                     'it': 'è falso',                                         'es': 'Es falso'};
Blockly.Words['on_help']                              = {'en': 'on---subscribe-on-changes-or-updates-of-some-state', 'de': 'on---subscribe-on-changes-or-updates-of-some-state', 'ru': 'on---subscribe-on-changes-or-updates-of-some-state', 'pt': 'on---subscribe-on-changes-or-updates-of-some-state', 'nl': 'on---subscribe-on-changes-or-updates-of-some-state', 'fr': 'on---subscribe-on-changes-or-updates-of-some-state', 'it': 'on---subscribe-on-changes-or-updates-of-some-state', 'es': 'on---subscribe-on-changes-or-updates-of-some-state'};
Blockly.Words['on_ack']                               = {'en': 'Ack is',                                          'de': 'anerkannt ist',                                   'ru': 'Подтверждение',                                   'pt': 'Ack é',                                           'nl': 'Ack is',                                          'fr': 'Ack est',                                         'it': 'Ack è',                                           'es': 'Ack es'};
Blockly.Words['on_ack_any']                           = {'en': 'any',                                             'de': 'egal',                                            'ru': 'не важно',                                        'pt': 'qualquer',                                        'nl': 'ieder',                                           'fr': 'tout',                                            'it': 'qualunque',                                       'es': 'alguna'};
Blockly.Words['on_ack_true']                          = {'en': 'update',                                          'de': 'Update',                                          'ru': 'обновление',                                      'pt': 'atualizar',                                       'nl': 'bijwerken',                                       'fr': 'mettre à jour',                                   'it': 'aggiornare',                                      'es': 'actualizar'};
Blockly.Words['on_ack_false']                         = {'en': 'command',                                         'de': 'Befehl',                                          'ru': 'команда',                                         'pt': 'comando',                                         'nl': 'opdracht',                                        'fr': 'commander',                                       'it': 'comando',                                         'es': 'mando'};
Blockly.Words['on_ext']                               = {'en': 'Event: if objects',                               'de': 'Falls Objekt',                                    'ru': 'Событие: если объект',                            'pt': 'Evento: se objetos',                              'nl': 'Evenement: als objecten',                         'fr': 'Evénement: si des objets',                        'it': 'Evento: se oggetti',                              'es': 'Evento: si los objetos'};
Blockly.Words['on_ext_tooltip']                       = {'en': 'If some state changed or updated',                'de': 'Bei Zustandsänderung',                            'ru': 'При изменении или обновлении состояния',          'pt': 'Se algum estado mudou ou atualizou',              'nl': 'Als een bepaalde staat is gewijzigd of bijgewerkt', 'fr': 'Si un état a été modifié ou mis à jour',          'it': 'Se qualche stato è cambiato o aggiornato',        'es': 'Si algún estado cambió o se actualizó'};
Blockly.Words['on_ext_oid']                           = {'en': 'object ID',                                       'de': 'Objekt ID',                                       'ru': 'ID объекта',                                      'pt': 'ID do objeto',                                    'nl': 'object-ID',                                       'fr': 'ID d\'objet',                                     'it': 'ID oggetto',                                      'es': 'ID de objeto'};
Blockly.Words['on_ext_oid_tooltip']                   = {'en': 'Object ID',                                       'de': 'Objekt ID',                                       'ru': 'ID объекта',                                      'pt': 'ID do objeto',                                    'nl': 'Object ID',                                       'fr': 'ID de l\'objet',                                  'it': 'ID oggetto',                                      'es': 'ID del objeto'};
Blockly.Words['on_ext_on']                            = {'en': 'trigger on',                                      'de': 'falls Trigger auf',                               'ru': 'если cобытие',                                    'pt': 'gatilho',                                         'nl': 'trigger aan',                                     'fr': 'déclencher',                                      'it': 'innesco su',                                      'es': 'desencadenar'};
Blockly.Words['on_ext_on_tooltip']                    = {'en': 'trigger on',                                      'de': 'falls Trigger auf',                               'ru': 'если cобытие',                                    'pt': 'gatilho',                                         'nl': 'trigger aan',                                     'fr': 'déclencher',                                      'it': 'innesco su',                                      'es': 'desencadenar'};
Blockly.Words['on']                                   = {'en': 'Event: if object',                                'de': 'falls Objekt',                                    'ru': 'Событие: если объект',                            'pt': 'Evento: se objeto',                               'nl': 'Evenement: als object',                           'fr': 'Evénement: si objet',                             'it': 'Evento: se oggetto',                              'es': 'Evento: si el objeto'};
Blockly.Words['on_tooltip']                           = {'en': 'If some state changed or updated',                'de': 'Bei Zustandsänderung',                            'ru': 'При изменении или обновлении состояния',          'pt': 'Se algum estado mudou ou atualizou',              'nl': 'Als een bepaalde staat is gewijzigd of bijgewerkt', 'fr': 'Si un état a été modifié ou mis à jour',          'it': 'Se qualche stato è cambiato o aggiornato',        'es': 'Si algún estado cambió o se actualizó'};
Blockly.Words['on_source']                            = {'en': 'get',                                             'de': 'Nehme',                                           'ru': 'взять',                                           'pt': 'obter',                                           'nl': 'krijgen',                                         'fr': 'obtenir',                                         'it': 'ottenere',                                        'es': 'obtener'};
Blockly.Words['on_source_of']                         = {'en': 'of trigger',                                      'de': 'von Trigger',                                     'ru': 'триггера',                                        'pt': 'de gatilho',                                      'nl': 'van trigger',                                     'fr': 'de déclenchement',                                'it': 'di innesco',                                      'es': 'de gatillo'};
Blockly.Words['on_source_tooltip']                    = {'en': 'Get information about event',                     'de': 'Hole die Information über Ereignis',              'ru': 'Получить информацию о событии',                   'pt': 'Obter informações sobre o evento',                'nl': 'Krijg informatie over het evenement',             'fr': 'Obtenir des informations sur l\'événement',       'it': 'Ottieni informazioni sull\'evento',               'es': 'Obtener información sobre el evento'};
Blockly.Words['on_source_id']                         = {'en': 'object ID',                                       'de': 'Objekt ID',                                       'ru': 'ID объекта',                                      'pt': 'ID do objeto',                                    'nl': 'object-ID',                                       'fr': 'ID d\'objet',                                     'it': 'ID oggetto',                                      'es': 'ID de objeto'};
Blockly.Words['on_source_name']                       = {'en': 'name',                                            'de': 'Name',                                            'ru': 'имя',                                             'pt': 'nome',                                            'nl': 'naam',                                            'fr': 'prénom',                                          'it': 'nome',                                            'es': 'nombre'};
Blockly.Words['on_source_desc']                       = {'en': 'description',                                     'de': 'Beschreibung',                                    'ru': 'описание',                                        'pt': 'descrição',                                       'nl': 'Beschrijving',                                    'fr': 'la description',                                  'it': 'descrizione',                                     'es': 'descripción'};
Blockly.Words['on_source_channel_id']                 = {'en': 'channel ID',                                      'de': 'Kanal ID',                                        'ru': 'ID канала',                                       'pt': 'ID do canal',                                     'nl': 'Kanaal Nr',                                       'fr': 'Identifiant de la chaine',                        'it': 'Canale ID',                                       'es': 'Canal ID'};
Blockly.Words['on_source_channel_name']               = {'en': 'channel name',                                    'de': 'Kanalname ID',                                    'ru': 'имя канала',                                      'pt': 'nome do canal',                                   'nl': 'kanaal naam',                                     'fr': 'nom du canal',                                    'it': 'nome del canale',                                 'es': 'Nombre del Canal'};
Blockly.Words['on_source_device_id']                  = {'en': 'device ID',                                       'de': 'Gerät ID',                                        'ru': 'ID устройства',                                   'pt': 'ID de dispositivo',                               'nl': 'apparaat ID',                                     'fr': 'Reference de l\'appareil',                        'it': 'ID del dispositivo',                              'es': 'ID del dispositivo'};
Blockly.Words['on_source_device_name']                = {'en': 'device name',                                     'de': 'Gerätename',                                      'ru': 'имя устройства',                                  'pt': 'nome do dispositivo',                             'nl': 'toestelnaam',                                     'fr': 'nom de l\'appareil',                              'it': 'nome del dispositivo',                            'es': 'nombre del dispositivo'};
Blockly.Words['on_source_state_val']                  = {'en': 'state value',                                     'de': 'Wert',                                            'ru': 'значение',                                        'pt': 'valor do estado',                                 'nl': 'staatswaarde',                                    'fr': 'valeur d\'état',                                  'it': 'valore di stato',                                 'es': 'valor de estado'};
Blockly.Words['on_source_state_ts']                   = {'en': 'state timestamp',                                 'de': 'Zeitstempel',                                     'ru': 'время',                                           'pt': 'timestamp de estado',                             'nl': 'staat tijdstempel',                               'fr': 'horodatage de l\'état',                           'it': 'timestamp di stato',                              'es': 'marca de tiempo del estado'};
Blockly.Words['on_source_state_q']                    = {'en': 'state quality',                                   'de': 'Qualität',                                        'ru': 'качество',                                        'pt': 'qualidade do estado',                             'nl': 'staat kwaliteit',                                 'fr': 'qualité de l\'état',                              'it': 'qualità dello stato',                             'es': 'calidad del estado'};
Blockly.Words['on_source_state_from']                 = {'en': 'origin of value',                                 'de': 'Ursprung',                                        'ru': 'происхождение',                                   'pt': 'origem do valor',                                 'nl': 'oorsprong van waarde',                            'fr': 'origine de la valeur',                            'it': 'origine del valore',                              'es': 'origen del valor'};
Blockly.Words['on_source_state_ack']                  = {'en': 'is command or update',                            'de': 'Befehl oder Aktualisierung',                      'ru': 'команда или обновление',                          'pt': 'é comando ou atualização',                        'nl': 'is commando of update',                           'fr': 'est la commande ou la mise à jour',               'it': 'è comando o aggiornamento',                       'es': 'es comando o actualización'};
Blockly.Words['on_source_state_lc']                   = {'en': 'last change of state',                            'de': 'letzte Änderung',                                 'ru': 'последнее изменение',                             'pt': 'última mudança de estado',                        'nl': 'laatste verandering van staat',                   'fr': 'dernier changement d\'état',                      'it': 'ultimo cambio di stato',                          'es': 'último cambio de estado'};
Blockly.Words['on_source_oldstate_val']               = {'en': 'previous value',                                  'de': 'vorheriger Wert',                                 'ru': 'предыдущее значение',                             'pt': 'valor anterior',                                  'nl': 'vorige waarde',                                   'fr': 'valeur précédente',                               'it': 'valore precedente',                               'es': 'valor anterior'};
Blockly.Words['on_source_oldstate_ts']                = {'en': 'previous timestamp',                              'de': 'vorheriger Zeitstempel',                          'ru': 'предыдущее время',                                'pt': 'timestamp anterior',                              'nl': 'vorige timestamp',                                'fr': 'Horodatage précédent',                            'it': 'timestamp precedente',                            'es': 'fecha y hora anterior'};
Blockly.Words['on_source_oldstate_q']                 = {'en': 'previous quality',                                'de': 'vorherige Quialität',                             'ru': 'предыдущее качество',                             'pt': 'qualidade anterior',                              'nl': 'vorige kwaliteit',                                'fr': 'qualité précédente',                              'it': 'qualità precedente',                              'es': 'calidad previa'};
Blockly.Words['on_source_oldstate_from']              = {'en': 'previous origin',                                 'de': 'vorherige Ursprung',                              'ru': 'предыдущее происхождение',                        'pt': 'origem anterior',                                 'nl': 'vorige oorsprong',                                'fr': 'origine précédente',                              'it': 'origine precedente',                              'es': 'origen anterior'};
Blockly.Words['on_source_oldstate_ack']               = {'en': 'previous command or update',                      'de': 'vorheriges Ack',                                  'ru': 'предыдущее команда или обновление',               'pt': 'comando ou atualização anterior',                 'nl': 'vorige opdracht of update',                       'fr': 'commande précédente ou mise à jour',              'it': 'comando precedente o aggiornamento',              'es': 'comando anterior o actualización'};
Blockly.Words['on_source_oldstate_lc']                = {'en': 'previous last change',                            'de': 'vorherige letzte Änderung',                       'ru': 'предыдущее последнее изменение',                  'pt': 'última mudança anterior',                         'nl': 'vorige laatste wijziging',                        'fr': 'précédent dernier changement',                    'it': 'precedente ultima modifica',                      'es': 'último cambio anterior'};
Blockly.Words['on_source_warning']                    = {'en': 'This block must be used only inside of event block', 'de': 'Dieser Block darf nur innerhalb "Falls Objekt" Block verwendet werden', 'ru': 'Этот блок можно использовать только внутри блока "Событие"', 'pt': 'Este bloco deve ser usado apenas dentro do bloco de eventos', 'nl': 'Dit blok mag alleen binnen het gebeurtenisblok worden gebruikt', 'fr': 'Ce bloc doit être utilisé uniquement à l\'intérieur du bloc d\'événements', 'it': 'Questo blocco deve essere utilizzato solo all\'interno del blocco eventi', 'es': 'Este bloque debe usarse solo dentro del bloque de evento'};

// --- trigger schedule --------------------------------------------------
Blockly.Words['schedule']                             = {'en': 'schedule',                                        'de': 'Zeitplan',                                        'ru': 'Cron расписание',                                 'pt': 'cronograma',                                      'nl': 'planning',                                        'fr': 'programme',                                       'it': 'programma',                                       'es': 'programar'};
Blockly.Words['schedule_tooltip']                     = {'en': 'Do something on cron schedule',                   'de': 'Ausführen nach Zeitplan',                         'ru': 'Выполнять по расписанию',                         'pt': 'Faça algo no cron schedule',                      'nl': 'Doe iets op cron-schema',                         'fr': 'Faire quelque chose sur le calendrier cron',      'it': 'Fai qualcosa su cron schedule',                   'es': 'Hacer algo en el cronograma cron'};
Blockly.Words['schedule_help']                        = {'en': 'schedule',                                        'de': 'schedule',                                        'ru': 'schedule',                                        'pt': 'cronograma',                                      'nl': 'planning',                                        'fr': 'programme',                                       'it': 'programma',                                       'es': 'programar'};

// --- trigger astro --------------------------------------------------
Blockly.Words['astro']                                = {'en': 'astro',                                           'de': 'Astro',                                           'ru': 'Астро',                                           'pt': 'astro',                                           'nl': 'astro',                                           'fr': 'astro',                                           'it': 'astro',                                           'es': 'astro'};
Blockly.Words['astro_tooltip']                        = {'en': 'Do something on astrological event',              'de': 'Ausführen nach Astro-Ereignis',                   'ru': 'Выполнять по астро-событию',                      'pt': 'Faça algo no evento astrológico',                 'nl': 'Doe iets over astrologische gebeurtenissen',      'fr': 'Faire quelque chose sur l\'événement astrologique', 'it': 'Fai qualcosa sull\'evento astrologico',           'es': 'Haz algo en el evento astrológico'};
Blockly.Words['astro_offset']                         = {'en': ', offset',                                        'de': ', Versatz',                                       'ru': ', сдвиг',                                         'pt': ', offset',                                        'nl': ', offset',                                        'fr': ', décalage',                                      'it': ', compensare',                                    'es': ', compensar'};
Blockly.Words['astro_minutes']                        = {'en': 'minutes',                                         'de': 'Minuten',                                         'ru': 'минут',                                           'pt': 'minutos',                                         'nl': 'notulen',                                         'fr': 'minutes',                                         'it': 'minuti',                                          'es': 'minutos'};
Blockly.Words['astro_sunriseText']                    = {'en': 'sunrise',                                         'de': 'Sonnenaufgang',                                   'ru': 'восход солнца',                                   'pt': 'nascer do sol',                                   'nl': 'zonsopkomst',                                     'fr': 'lever du soleil',                                 'it': 'Alba',                                            'es': 'amanecer'};
Blockly.Words['astro_sunriseEndText']                 = {'en': 'sunrise end',                                     'de': 'Sonnenaufgang-Ende',                              'ru': 'конец восхода',                                   'pt': 'fim do nascer do sol',                            'nl': 'zonsopgang einde',                                'fr': 'fin du lever du soleil',                          'it': 'alba fine',                                       'es': 'salida del sol'};
Blockly.Words['astro_goldenHourEndText']              = {'en': 'golden hour end',                                 'de': '"Golden hour"-Ende',                              'ru': 'конец золотого часа',                             'pt': 'hora da hora dourada',                            'nl': 'gouden uureinde',                                 'fr': 'fin de l\'heure d\'or',                           'it': 'ora d\'oro fine',                                 'es': 'hora dorada'};
Blockly.Words['astro_solarNoonText']                  = {'en': 'solar noon',                                      'de': 'Sonnenmittag',                                    'ru': 'солнечеый полдень',                               'pt': 'meio-dia solar',                                  'nl': 'zonne middag',                                    'fr': 'midi solaire',                                    'it': 'mezzogiorno solare',                              'es': 'mediodía solar'};
Blockly.Words['astro_goldenHourText']                 = {'en': 'golden hour',                                     'de': '"Golden hour"',                                   'ru': 'золотой час',                                     'pt': 'Hora dourada',                                    'nl': 'gouden uur',                                      'fr': 'heure d\'or',                                     'it': 'ora d\'oro',                                      'es': 'hora dorada'};
Blockly.Words['astro_sunsetStartText']                = {'en': 'sunset start',                                    'de': 'Sonnenuntergang-Anfang',                          'ru': 'начало захода солнца',                            'pt': 'começo do por do sol',                            'nl': 'zonsondergang start',                             'fr': 'coucher de soleil début',                         'it': 'inizio del tramonto',                             'es': 'puesta de sol'};
Blockly.Words['astro_sunsetText']                     = {'en': 'sunset',                                          'de': 'Sonnenuntergang',                                 'ru': 'конец захода солнца',                             'pt': 'por do sol',                                      'nl': 'zonsondergang',                                   'fr': 'le coucher du soleil',                            'it': 'tramonto',                                        'es': 'puesta de sol'};
Blockly.Words['astro_duskText']                       = {'en': 'dusk',                                            'de': 'Abenddämmerung',                                  'ru': 'сумерки',                                         'pt': 'crepúsculo',                                      'nl': 'schemer',                                         'fr': 'crépuscule',                                      'it': 'crepuscolo',                                      'es': 'oscuridad'};
Blockly.Words['astro_nauticalDuskText']               = {'en': 'nautical dusk',                                   'de': 'Nautische Abenddämmerung',                        'ru': 'навигационные сумерки',                           'pt': 'crepúsculo náutico',                              'nl': 'nautische schemering',                            'fr': 'crépuscule nautique',                             'it': 'crepuscolo nautico',                              'es': 'anochecer náutico'};
Blockly.Words['astro_nightText']                      = {'en': 'night',                                           'de': 'Nacht',                                           'ru': 'ночь',                                            'pt': 'noite',                                           'nl': 'nacht',                                           'fr': 'nuit',                                            'it': 'notte',                                           'es': 'noche'};
Blockly.Words['astro_nightEndText']                   = {'en': 'night end',                                       'de': 'Nachtsende',                                      'ru': 'конец ночи',                                      'pt': 'final da noite',                                  'nl': 'einde van de nacht',                              'fr': 'fin de nuit',                                     'it': 'fine della notte',                                'es': 'fin de noche'};
Blockly.Words['astro_nauticalDawnText']               = {'en': 'nautical dawn',                                   'de': 'Nautische Morgendämmerung',                       'ru': 'навигационный рассвет',                           'pt': 'amanhecer náutico',                               'nl': 'nautische dageraad',                              'fr': 'aube nautique',                                   'it': 'alba nautica',                                    'es': 'amanecer náutico'};
Blockly.Words['astro_dawnText']                       = {'en': 'dawn',                                            'de': 'Morgendämmerung',                                 'ru': 'рассвет',                                         'pt': 'alvorecer',                                       'nl': 'dageraad',                                        'fr': 'Aube',                                            'it': 'alba',                                            'es': 'amanecer'};
Blockly.Words['astro_nadirText']                      = {'en': 'nadir',                                           'de': 'Nadir',                                           'ru': 'надир',                                           'pt': 'nadir',                                           'nl': 'nadir',                                           'fr': 'nadir',                                           'it': 'nadir',                                           'es': 'nadir'};
Blockly.Words['astro_help']                           = {'en': 'astro--function',                                 'de': 'astro--function',                                 'ru': 'astro--function',                                 'pt': 'astro--function',                                 'nl': 'astro--function',                                 'fr': 'astro--function',                                 'it': 'astro--function',                                 'es': 'astro--function'};

// --- trigger schedule --------------------------------------------------
Blockly.Words['schedule_create']                      = {'en': 'schedule',                                        'de': 'Zeitplan',                                        'ru': 'Расписание',                                      'pt': 'cronograma',                                      'nl': 'planning',                                        'fr': 'programme',                                       'it': 'programma',                                       'es': 'programar'};
Blockly.Words['schedule_create_name']                 = {'en': 'schedule',                                        'de': 'Zeitplan',                                        'ru': 'Расписание',                                      'pt': 'cronograma',                                      'nl': 'planning',                                        'fr': 'programme',                                       'it': 'programma',                                       'es': 'programar'};
Blockly.Words['schedule_text']                        = {'en': 'cron rule',                                       'de': 'CRON Regel',                                      'ru': 'cron правило',                                    'pt': 'regra cron',                                      'nl': 'cron-regel',                                      'fr': 'règle cron',                                      'it': 'regola cron',                                     'es': 'regla cron'};
Blockly.Words['schedule_create_tooltip']              = {'en': 'Delay execution',                                 'de': 'Ausführung verzögern',                            'ru': 'Сделать паузу',                                   'pt': 'Atrasar a execução',                              'nl': 'Vertraag uitvoering',                             'fr': 'Retarder l\'exécution',                           'it': 'Ritardare l\'esecuzione',                         'es': 'Demora de ejecución'};
Blockly.Words['schedule_create_help']                 = {'en': 'settimeout',                                      'de': 'settimeout',                                      'ru': 'settimeout',                                      'pt': 'settimeout',                                      'nl': 'setTimeout',                                      'fr': 'settimeout',                                      'it': 'setTimeout',                                      'es': 'settimeout'};
Blockly.Words['schedule_clear']                       = {'en': 'clear',                                           'de': 'stop',                                            'ru': 'остановить',                                      'pt': 'Claro',                                           'nl': 'duidelijk',                                       'fr': 'clair',                                           'it': 'chiaro',                                          'es': 'claro'};
Blockly.Words['schedule_clear_tooltip']               = {'en': 'Clear delay execution',                           'de': 'Ausführungsverzögerung anhalten',                 'ru': 'Отменить выполнение с паузой',                    'pt': 'Execução de atraso clara',                        'nl': 'Duidelijke uitvoering van vertragingen',          'fr': 'Effacer l\'exécution du délai',                   'it': 'Cancella l\'esecuzione del ritardo',              'es': 'Ejecución de retraso claro'};
Blockly.Words['schedule_clear_help']                  = {'en': 'cleartimeout',                                    'de': 'cleartimeout',                                    'ru': 'cleartimeout',                                    'pt': 'cleartimeout',                                    'nl': 'clearTimeout',                                    'fr': 'cleartimeout',                                    'it': 'clearTimeout',                                    'es': 'cleartimeout'};

// --- trigger field --------------------------------------------------
Blockly.Words['field_cron']                           = {'en': 'CRON',                                            'de': 'CRON',                                            'ru': 'CRON',                                            'pt': 'CRON',                                            'nl': 'CRON',                                            'fr': 'CRON',                                            'it': 'CRON',                                            'es': 'CRON'};
Blockly.Words['field_cron_CRON']                      = {'en': 'CRON',                                            'de': 'CRON',                                            'ru': 'CRON',                                            'pt': 'CRON',                                            'nl': 'CRON',                                            'fr': 'CRON',                                            'it': 'CRON',                                            'es': 'CRON'};
Blockly.Words['field_cron_tooltip']                   = {'en': 'Create CRON rule with dialog',                    'de': 'Erzeuge CRON Regel mit Dialog',                   'ru': 'Создать CRON правило с помощью диалога',          'pt': 'Criar regra CRON com diálogo',                    'nl': 'Maak CRON-regel met dialoogvenster',              'fr': 'Créer une règle CRON avec dialogue',              'it': 'Crea una regola CRON con finestra di dialogo',    'es': 'Crear regla CRON con diálogo'};

// --- trigger cron --------------------------------------------------
Blockly.Words['cron_builder']                         = {'en': 'CRON',                                            'de': 'CRON',                                            'ru': 'CRON',                                            'pt': 'CRON',                                            'nl': 'CRON',                                            'fr': 'CRON',                                            'it': 'CRON',                                            'es': 'CRON'};
Blockly.Words['cron_builder_CRON']                    = {'en': 'CRON',                                            'de': 'CRON',                                            'ru': 'CRON',                                            'pt': 'CRON',                                            'nl': 'CRON',                                            'fr': 'CRON',                                            'it': 'CRON',                                            'es': 'CRON'};
Blockly.Words['cron_builder_tooltip']                 = {'en': 'Create CRON rule with dialog',                    'de': 'Erzeuge CRON Regel mit Dialog',                   'ru': 'Создать CRON правило с помощью диалога',          'pt': 'Criar regra CRON com diálogo',                    'nl': 'Maak CRON-regel met dialoogvenster',              'fr': 'Créer une règle CRON avec dialogue',              'it': 'Crea una regola CRON con finestra di dialogo',    'es': 'Crear regla CRON con diálogo'};
Blockly.Words['cron_builder_with_seconds']            = {'en': 'with seconds',                                    'de': 'mit Sekunden',                                    'ru': 'с секундами',                                     'pt': 'com segundos',                                    'nl': 'met seconden',                                    'fr': 'avec secondes',                                   'it': 'con secondi',                                     'es': 'con segundos'};
Blockly.Words['cron_builder_dow']                     = {'en': 'day of week',                                     'de': 'Wochentag',                                       'ru': 'день недели',                                     'pt': 'dia da semana',                                   'nl': 'dag van de week',                                 'fr': 'jour de la semaine',                              'it': 'giorno della settimana',                          'es': 'día de la semana'};
Blockly.Words['cron_builder_month']                   = {'en': 'month',                                           'de': 'Monat',                                           'ru': 'месяц',                                           'pt': 'mês',                                             'nl': 'maand',                                           'fr': 'mois',                                            'it': 'mese',                                            'es': 'mes'};
Blockly.Words['cron_builder_day']                     = {'en': 'date',                                            'de': 'Datum',                                           'ru': 'число',                                           'pt': 'encontro',                                        'nl': 'datum',                                           'fr': 'rendez-vous amoureux',                            'it': 'Data',                                            'es': 'fecha'};
Blockly.Words['cron_builder_hour']                    = {'en': 'hour',                                            'de': 'Stunde',                                          'ru': 'час',                                             'pt': 'hora',                                            'nl': 'uur',                                             'fr': 'heure',                                           'it': 'ora',                                             'es': 'hora'};
Blockly.Words['cron_builder_minutes']                 = {'en': 'minutes',                                         'de': 'Minuten',                                         'ru': 'минуты',                                          'pt': 'minutos',                                         'nl': 'notulen',                                         'fr': 'minutes',                                         'it': 'minuti',                                          'es': 'minutos'};
Blockly.Words['cron_builder_seconds']                 = {'en': 'seconds',                                         'de': 'Sekunden',                                        'ru': 'секунды',                                         'pt': 'segundos',                                        'nl': 'seconden',                                        'fr': 'secondes',                                        'it': 'secondi',                                         'es': 'segundos'};
Blockly.Words['cron_builder_line']                    = {'en': 'as line',                                         'de': 'Als Linie',                                       'ru': 'в линию',                                         'pt': 'como linha',                                      'nl': 'als lijn',                                        'fr': 'en ligne',                                        'it': 'come linea',                                      'es': 'como línea'};
