@topconsultnpm/sdkui-react 6.21.0-dev2.4 → 6.21.0-dev2.41

package/lib/helper/SDKUI_Localizator.js

@@ -484,6 +484,16 @@ export class SDKUI_Localizator {
             default: return "Archivia documento master";
         }
     }
+    static get Archiving() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Archivierung";
+            case CultureIDs.En_US: return "Archiving";
+            case CultureIDs.Es_ES: return "Archivación";
+            case CultureIDs.Fr_FR: return "Archivage";
+            case CultureIDs.Pt_PT: return "Arquivamento";
+            default: return "Archiviazione";
+        }
+    }
     static get Arguments() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Themen";
@@ -805,6 +815,16 @@ export class SDKUI_Localizator {
             default: return "Annulla";
         }
     }
+    static get CancelAndClose() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Abbrechen und schließen";
+            case CultureIDs.En_US: return "Cancel and close";
+            case CultureIDs.Es_ES: return "Cancelar y cerrar";
+            case CultureIDs.Fr_FR: return "Annuler et fermer";
+            case CultureIDs.Pt_PT: return "Cancelar e fechar";
+            default: return "Annulla e chiudi";
+        }
+    }
     static get ChangePassword() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Kennwort ändern";
@@ -990,6 +1010,16 @@ export class SDKUI_Localizator {
             default: return "Cancella OTP";
         }
     }
+    static get ClickToBrowseFile() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Klicken Sie, um Ihre Datei zu durchsuchen";
+            case CultureIDs.En_US: return "Click to browse your file";
+            case CultureIDs.Es_ES: return "Haz clic para explorar tu archivo";
+            case CultureIDs.Fr_FR: return "Cliquez pour parcourir votre fichier";
+            case CultureIDs.Pt_PT: return "Clique para navegar no seu arquivo";
+            default: return "Clicca per sfogliare il tuo file";
+        }
+    }
     static get Close() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ausgang";
@@ -2029,6 +2059,16 @@ export class SDKUI_Localizator {
             default: return "Bozze";
         }
     }
+    static get DragOrDoubleClickToBrowseFile() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ziehen Sie Ihre Datei hierher oder doppelklicken Sie, um sie zu durchsuchen";
+            case CultureIDs.En_US: return "Drag your file or double click to browse";
+            case CultureIDs.Es_ES: return "Arrastra tu archivo o haz doble clic para explorarlo";
+            case CultureIDs.Fr_FR: return "Glissez votre fichier ou double-cliquez pour le parcourir";
+            case CultureIDs.Pt_PT: return "Arraste seu arquivo ou clique duas vezes para navegar";
+            default: return "Trascina il tuo file o fai doppio click per sfogliarlo";
+        }
+    }
     static get DropFileHere() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ziehen Sie Ihre Datei hierher";
@@ -2847,6 +2887,478 @@ export class SDKUI_Localizator {
             default: return "Editor delle formule";
         }
     }
+    //=============
+    static get FormulaEditor_DescFunction_ORA_ADD_MONTHS() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "ADD_MONTHS liefert das Datum plus die angegebenen Monate";
+            case CultureIDs.En_US: return "ADD_MONTHS returns the date date plus integer months";
+            case CultureIDs.Es_ES: return "ADD_MONTHS  devuelve la fecha más los meses indicados";
+            case CultureIDs.Fr_FR: return "ADD_MONTHS ajoute à la date le nombre integer  des mois";
+            case CultureIDs.Pt_PT: return "ADD_MONTHS retorna a data data mais meses inteiros";
+            default: return "ADD_MONTHS  restituisce la data  più i mesi indicati";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_LAST_DAY() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "LAST_DAY gibt den letzten Tag des Monats des angegebenen Datums zurück";
+            case CultureIDs.En_US: return "LAST_DAY returns the date of the last day of the month that contains date";
+            case CultureIDs.Es_ES: return "LAST_DAY  devuelve el último día del mes de la fecha indicada";
+            case CultureIDs.Fr_FR: return "LAST_DAY renvoie la date du dernier jour du mois qui contient la date";
+            case CultureIDs.Pt_PT: return "LAST_DAY devolve a data do último dia do mês que contém a data";
+            default: return "LAST_DAY  restituisce l'ultimo giorno del mese della data indicata";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_LENGTH() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "LENGTH gibt die Anzahl der Zeichen zurück";
+            case CultureIDs.En_US: return "The LENGTH functions return the length of char";
+            case CultureIDs.Es_ES: return "LENGTH devuelve el número de caracteres";
+            case CultureIDs.Fr_FR: return "les LENGTH fonctions renvoie la longueur du char";
+            case CultureIDs.Pt_PT: return "As funções LEGTH retornar o comprimento de cha";
+            default: return "LENGTH restituisce il numero di caratteri";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_LOWER() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "LOWER gibt die Zeichenkette mit allen Kleinbuchstaben zurück";
+            case CultureIDs.En_US: return "LOWER returns char, with all letters lowercase";
+            case CultureIDs.Es_ES: return "LOWER devuelve la cadena con todos los caracteres minúsculos";
+            case CultureIDs.Fr_FR: return "LOWER renvoie char, avec toutes les lettres en minuscules";
+            case CultureIDs.Pt_PT: return "LOWER retorna char, com todas as letras minúsculas";
+            default: return "LOWER restituisce la stringa con tutti i caratteri minuscoli";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_REPLACE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "REPLACE gibt die Zeichenkette bei jedem Auftreten von search_string zurück, ersetzt durch replacement_string";
+            case CultureIDs.En_US: return "REPLACE returns char with every occurrence of search_string replaced with replacement_string";
+            case CultureIDs.Es_ES: return "REPLACE devuelve la cadena cada vez que aparece search_string sustituida con replacement_string";
+            case CultureIDs.Fr_FR: return "REPLACE retourne le caractère par chaque occurrence de serach_string remplacé par replacement_string";
+            case CultureIDs.Pt_PT: return "REPLACE returns char with every occurrence of search_string replaced with replacement_string";
+            default: return "REPLACE restituisce la stringa con ogni occorrenza di search_string sostituito con replacement_string";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_SUBSTR() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "SUBSTR gibt einen Teil einer Zeichenkette, beginnend mit dem Positionszeichen, für eine Länge von substring_length Zeichen zurück";
+            case CultureIDs.En_US: return "The SUBSTR functions return a portion of char, beginning at character position, substring_length characters long";
+            case CultureIDs.Es_ES: return "SUBSTR devuelve una parte de cadena, comenzando por el carácter position, con una longitud de  substring_length caracteres";
+            case CultureIDs.Fr_FR: return "Les fonctions SUBSTR renvoient une partie de char, commençant à la position de caractère, caractères substring_length longue";
+            case CultureIDs.Pt_PT: return "The SUBSTR functions return a portion of char, beginning at character position, substring_length characters long";
+            default: return "SUBSTR restituisce una porzione di stringa, iniziando dal carattere position, per una lunghezza di substring_length caratteri";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_SYSDATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "SYSDATE gibt das aktuelle Datum und die aktuelle Uhrzeit des Betriebssystems zurück, auf dem sich die Datenbank befindet";
+            case CultureIDs.En_US: return "SYSDATE returns the current date and time set for the operating system on which the database resides";
+            case CultureIDs.Es_ES: return "SYSDATE devuelve fecha y hora actual configurada por el sistema operativo en el cual reside la base de datos";
+            case CultureIDs.Fr_FR: return "SYSDATE renvoie la date et l'heure fixée pour le système d'exploitation sur lequel réside la base de données";
+            case CultureIDs.Pt_PT: return "SYSDATE returns the current date and time set for the operating system on which the database resides";
+            default: return "SYSDATE restituisce data e ora corrente impostata per il sistema operativo sul quale il database risiede";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_TOCHARDATETIME() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "TO_CHAR (datetime) konvertiert eine Datums- oder Intervallzeit von DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE oder TIMESTAMP WITH LOCAL TIME ZONE in einen Wert vom Typ VARCHAR2 im angegebenen Format";
+            case CultureIDs.En_US: return "TO_CHAR (datetime) converts a datetime or interval value of DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, or TIMESTAMP WITH LOCAL TIME ZONE datatype to a value of VARCHAR2 datatype in the format specified by the date format fmt";
+            case CultureIDs.Es_ES: return "TO_CHAR (datetime) convierte un datetime o un intervalo de  DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, o TIMESTAMP WITH LOCAL TIME ZONE  en un valor de tipo VARCHAR2 en el formato especificado";
+            case CultureIDs.Fr_FR: return "TO_CHAR (datetime) convertit la date ou l'intervalle de valeur DATE, TIMESTAMP, timestamp with time zone, ou TIMESTAMP WITH LOCAL TIME ZONE type de données à une valeur de type de données VARCHAR2 dans le format spécifié par le format de date fmt";
+            case CultureIDs.Pt_PT: return "TO_CHAR (datetime) converts a datetime or interval value of DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, or TIMESTAMP WITH LOCAL TIME ZONE datatype to a value of VARCHAR2 datatype in the format specified by the date format fmt (PT)";
+            default: return "TO_CHAR (datetime) converte un datetime o un intervallo di  DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE, o TIMESTAMP WITH LOCAL TIME ZONE  in un valore di tipo VARCHAR2 nel formato specificato";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_TO_DATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "TO_DATE konvertiert eine Zeichenkette vom Typ CHAR, VARCHAR2, NCHAR oder NVARCHAR2 in einen Wert vom Typ DATE";
+            case CultureIDs.En_US: return "TO_DATE converts char of CHAR, VARCHAR2, NCHAR, or NVARCHAR2 datatype to a value of DATE datatype";
+            case CultureIDs.Es_ES: return "TO_DATE convierte una cadena de tipo CHAR, VARCHAR2, NCHAR, o NVARCHAR2 en un valor de tipo DATE";
+            case CultureIDs.Fr_FR: return "TO_DATE convertit le char en CHAR, VARCHAR2, NCHAR, NVARCHAR2 ou le type de données à une valeur de type de données DATE";
+            case CultureIDs.Pt_PT: return "TO_DATE converts char of CHAR, VARCHAR2, NCHAR, or NVARCHAR2 datatype to a value of DATE datatype";
+            default: return "TO_DATE converte una stringa di  tipo CHAR, VARCHAR2, NCHAR, o NVARCHAR2 in un valore  di tipo DATE";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_TRIM() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Mit TRIM können Sie die Anfangs- oder Endzeichen (oder beide) einer Zeichenkette löschen. Wenn trim_character oder trim_source eine Zeichenkette ist, dann muss sie in einfache Anführungszeichen eingeschlossen werden";
+            case CultureIDs.En_US: return "TRIM enables you to trim leading or trailing characters (or both) from a character string. If trim_character or trim_source is a character literal, then you must enclose it in single quotes";
+            case CultureIDs.Es_ES: return "TRIM permite eliminar los caracteres iniciales o finales (o ambos) de una cadena de caracteres. Si trim_character o trim_source es una cadena, entonces es necesario ponerla entre comillas individuales";
+            case CultureIDs.Fr_FR: return "TRIM permet de couper avant ou arrière caractères (ou les deux) à partir d'une chaîne de caractères. Si trim_character ou trim_source est un caractère littéral, vous devez utiliser des guillemets simples";
+            case CultureIDs.Pt_PT: return "TRIM enables you to trim leading or trailing characters (or both) from a character string. If trim_character or trim_source is a character literal, then you must enclose it in single quotes";
+            default: return "TRIM consente di eliminare i caratteri iniziali o finali (o entrambi) da una stringa di caratteri. Se trim_character o trim_source è una stringa, allora è necessario racchiuderla tra virgolette singole";
+        }
+    }
+    static get FormulaEditor_DescFunction_ORA_UPPER() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "UPPER gibt die Zeichenkette mit Großbuchstaben zurück";
+            case CultureIDs.En_US: return "UPPER returns char, with all letters uppercase";
+            case CultureIDs.Es_ES: return "UPPER devuelve la cadena con caracteres en mayúscula";
+            case CultureIDs.Fr_FR: return "UPPER retourne char, avec toutes les lettres en majuscules";
+            case CultureIDs.Pt_PT: return "UPPER returns char, with all letters uppercase (PT)";
+            default: return "UPPER restituisce la stringa con caratteri maiuscoli";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_DATEADD() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert den angegebenen Datumswert mit dem angegebenen Zahlenwertbereich (ganze Zahlen mit Zeichen), der zu einem angegebenen Datenteilwert des angegebenen Datumswertes hinzugefügt wurde";
+            case CultureIDs.En_US: return "Returns a specified date with the specified number interval (signed integer) added to a specified datepart of that date";
+            case CultureIDs.Es_ES: return "Devuelve el valor date especificado con el intervalo con valores number especificado (enteros con signo) añadido a un valor datepart especificado por el valor date mismo";
+            case CultureIDs.Fr_FR: return "Retourne une date spécifiée avec l'intervalle number indiqué (entier signé) ajouté à une datepart spécifiée de cette date";
+            case CultureIDs.Pt_PT: return "Retorna a contagem em dias que se sobrepõem entre a startdate valores e endDate especificado";
+            default: return "Restituisce il valore date specificato con l'intervallo di valori number specificato (interi con segno) aggiunto a un valore datepart specificato del valore date stesso";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_CASE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "CASE wertet eine Liste von Bedingungen aus und gibt einen von so vielen Ergebnisausdrücken wie möglich zurück";
+            case CultureIDs.En_US: return "The CASE statement chooses from a sequence of conditions, and executes a corresponding statement";
+            case CultureIDs.Es_ES: return "CASE valora una lista de condiciones y devuelve una entre las expresiones de resultado posibles";
+            case CultureIDs.Fr_FR: return "L'instruction CASE choisit à partir d'une séquence de conditions, et exécute une instruction correspondante";
+            case CultureIDs.Pt_PT: return "The CASE statement chooses from a sequence of conditions, and executes a corresponding statement";
+            default: return "CASE valuta un elenco di condizioni e restituisce una tra più espressioni di risultato possibili";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_CAST() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "CAST konvertiert einen Ausdruck von einem Datentyp in einen anderen";
+            case CultureIDs.En_US: return "CAST converts one built-in datatype or collection-typed value into another built-in datatype or collection-typed value";
+            case CultureIDs.Es_ES: return "CAST convierte una expresión de un tipo de datos a otro";
+            case CultureIDs.Fr_FR: return "CAST convertit un type de données prédéfini ou valeur de la collection typée dans un autre type de données intégré ou valeur de la collection typée";
+            case CultureIDs.Pt_PT: return "CAST converts one built-in datatype or collection-typed value into another built-in datatype or collection-typed value (PT)";
+            default: return "CAST converte un'espressione da un tipo di dati a un altro";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_CASTnvarchar2() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "CAST konvertiert einen Ausdruck nach NVARCHAR2";
+            case CultureIDs.En_US: return "CAST converts an expression to NVARCHAR2";
+            case CultureIDs.Es_ES: return "CAST convierte una expresión a NVARCHAR2";
+            case CultureIDs.Fr_FR: return "CAST convertit une expression en NVARCHAR2";
+            case CultureIDs.Pt_PT: return "CAST converte uma expressão para NVARCHAR2";
+            default: return "CAST converte un'espressione in NVARCHAR2";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_CASTnumeric() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "CAST konvertiert einen Ausdruck nach NUMERIC";
+            case CultureIDs.En_US: return "CAST converts an expression to NUMERIC";
+            case CultureIDs.Es_ES: return "CAST convierte una expresión a NUMERIC";
+            case CultureIDs.Fr_FR: return "CAST convertit une expression en NUMERIC";
+            case CultureIDs.Pt_PT: return "CAST converte uma expressão para NUMERIC";
+            default: return "CAST converte un'espressione in NUMERIC";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_GREATEST() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "GREATEST gibt den größten Wert einer Liste oder von Ausdrücken zurück";
+            case CultureIDs.En_US: return "GREATEST returns the greatest of the list of one or more expressions";
+            case CultureIDs.Es_ES: return "GREATEST devuelve el mayor de una lista o de varias expresiones";
+            case CultureIDs.Fr_FR: return "GREATEST renvoie le plus de la liste d'un ou plusieurs expressions";
+            case CultureIDs.Pt_PT: return "Retornos GREATEST o maior da lista de um ou amoras expressões";
+            default: return "GREATEST restituisce il più grande di una lista o di più espressioni";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_IS_NULL() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Der Operator IS NULL gibt einen BOOLEAN zurück, der TRUE entspricht, wenn der Operand Null ist, FALSE, wenn er nicht Null ist";
+            case CultureIDs.En_US: return "The IS NULL operator returns the BOOLEAN value TRUE if its operand is null or FALSE if it is not null";
+            case CultureIDs.Es_ES: return "El operador IS NULL  devuelve un BOOLEAN igual a TRUE  si el operando es null, FALSE si no es nulo";
+            case CultureIDs.Fr_FR: return "L'opérateur NULL est retourne la valeur booléenne true si l'opérande est nulle ou FALSE si elle n'est pas nulle";
+            case CultureIDs.Pt_PT: return "The IS NULL operator returns the BOOLEAN value TRUE if its operand is null or FALSE if it is not null (PT)";
+            default: return "L'operatore  IS NULL  restituisce un  BOOLEAN uguale a TRUE  se l'operando è null, FALSE se non è nullo";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_LEAST() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "LEAST gibt die kleinste der Listen oder Ausdrücke zurück";
+            case CultureIDs.En_US: return "LEAST returns the least of the list of exprs";
+            case CultureIDs.Es_ES: return "LEAST devuelve el más pequeño de una lista o de varias expresiones";
+            case CultureIDs.Fr_FR: return "LEAST renvoie le moins de la liste des exprs";
+            case CultureIDs.Pt_PT: return "LEAST returns the least of the list of exprs";
+            default: return "LEAST restituisce il più piccolo di una lista o di più espressioni";
+        }
+    }
+    static get FormulaEditor_DescInstruction_ORA_NVL() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "NVL ermöglicht es Ihnen, null (als Leerzeichen zurückgegeben) durch eine Zeichenkette in den Ergebnissen einer Abfrage zu ersetzen";
+            case CultureIDs.En_US: return "NVL lets you replace null (returned as a blank) with a string in the results of a query. If expr1 is null, then NVL returns expr2. If expr1 is not null, then NVL returns expr1";
+            case CultureIDs.Es_ES: return "NVL permite sustituir null (devuelto como un espacio vacío) con una cadena en los resultados de una consulta";
+            case CultureIDs.Fr_FR: return "NVL vous permet de remplacer null (retourné comme un blanc) avec une chaîne dans les résultats d'une requête. Si expr1 est nul, alors les rendements NVL expr2. Si expr1 n'est pas nul, alors NVL retourne expr1";
+            case CultureIDs.Pt_PT: return "NVL lets you replace null (returned as a blank) with a string in the results of a query. If expr1 is null, then NVL returns expr2. If expr1 is not null, then NVL returns expr1";
+            default: return "NVL consente di sostituire null (restituito come uno spazio vuoto) con una stringa nei risultati di una query";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_DATEDIFFday() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert die Anzahl in Tagen, die sich zwischen den angegebenen Werten für Startdatum und Enddatum überschneiden";
+            case CultureIDs.En_US: return "Returns the count in days between the startdate and enddate defined values";
+            case CultureIDs.Es_ES: return "Devuelve el recuento en días que se superponen entre los valores startdate y enddate especificados";
+            case CultureIDs.Fr_FR: return "Retourne le nombre de jours qui se chevauchent entre les valeurs de startdate et enddate spécifié";
+            case CultureIDs.Pt_PT: return "Retorna a contagem em dias que se sobrepõem entre a startdate valores e endDate especificado";
+            default: return "Restituisce il conteggio in giorni che si sovrappongono tra i valori startdate e enddate specificati";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_DATEDIFFyear() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert die Anzahl in Jahren, die sich zwischen den angegebenen Werten für Startdatum und Enddatum überschneiden";
+            case CultureIDs.En_US: return "Returns the count in years between the startdate and enddate defined values";
+            case CultureIDs.Es_ES: return "Devuelve el recuento en años que se superponen entre los valores startdate y enddate especificados";
+            case CultureIDs.Fr_FR: return "Retourne le nombre des années qui se chevauchent entre les valeurs de startdate et enddate spécifié";
+            case CultureIDs.Pt_PT: return "Retorna a contagem nos anos que se sobrepõem entre os valores startdate e endDate especificado";
+            default: return "Restituisce il conteggio in anni che si sovrappongono tra i valori startdate e enddate specificati";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_DAYGETDATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert den Systemtag der aktuellen Datenbank als Datumszeitwert ohne die Zeitzonendifferenz der Datenbank";
+            case CultureIDs.En_US: return "Returns the system date of the current database as a datetime value not considering the time zone difference";
+            case CultureIDs.Es_ES: return "Devuelve el día del sistema de la base de datos actual como valor datetime sin la diferencia de huso horario de la base de datos";
+            case CultureIDs.Fr_FR: return "Retourne le jour de système de la base des données courante comme valeur datetime sans la différence de fuseau horaire de la base des donnée";
+            case CultureIDs.Pt_PT: return "Retorna o dia do atual sistema de banco de dados como um valor de data e hora, sem a diferença de tempo de banco de dados";
+            default: return "Restituisce il giorno di sistema del database corrente come valore datetime senza la differenza di fuso orario del database";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_GETDATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert den Systemzeitstempel der aktuellen Datenbank als Datums-Zeitwert ohne die Zeitzonendifferenz der Datenbank";
+            case CultureIDs.En_US: return "Returns the system timestamp of the current database as a datetime value not considering the time zone difference";
+            case CultureIDs.Es_ES: return "Devuelve el timestamp del sistema de la base de datos actual como valor datetime sin la diferencia de huso horario de la base de datos";
+            case CultureIDs.Fr_FR: return "Retourne le timestamp de système de la base des données courante comme valeur datetime sans la différence de fuseau horaire de la base des donnée";
+            case CultureIDs.Pt_PT: return "Retorna a data do atual sistema de banco de dados como um valor de data e hora, sem a diferença de tempo de banco de dados";
+            default: return "Restituisce il timestamp di sistema del database corrente come valore datetime senza la differenza di fuso orario del database";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_LEFT() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert den Anfangsteil einer Zeichenkette, der gleich lang wie die angegebene Anzahl von Zeichen ist";
+            case CultureIDs.En_US: return "Returns the initial part of a character string, its length tallying the specified length";
+            case CultureIDs.Es_ES: return "Devuelve la parte inicial de una cadena de caracteres, de longitud igual al número de caracteres especificado";
+            case CultureIDs.Fr_FR: return "Renvoie la partie initiale d'une chaîne de caractères de longueur égale au nombre de caractères spécifié";
+            case CultureIDs.Pt_PT: return "Retorna a parte inicial de uma cadeia de caracteres, de comprimento igual ao número especificado de caracteres";
+            default: return "Restituisce la parte iniziale di una stringa di caratteri, di lunghezza pari al numero di caratteri specificato";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_LEN() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert die Anzahl der Zeichen des angegebenen Zeichenkettenausdrucks, mit Ausnahme der letzten Leerzeichen";
+            case CultureIDs.En_US: return "Returns the number of characters of the specified string expression excluding trailing spaces";
+            case CultureIDs.Es_ES: return "Devuelve el número de caracteres de la expresión de cadena especificada, excluidos los espacios vacíos finales";
+            case CultureIDs.Fr_FR: return "Retourne le nombre de caractères de la chaîne spécifiée, à l'exclusion des ébauches de suivi";
+            case CultureIDs.Pt_PT: return "Retorna o número de caracteres da cadeia especificada, excluindo espaços no final";
+            default: return "Restituisce il numero di caratteri dell'espressione stringa specificata, esclusi gli spazi vuoti finali";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_LOWER() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Gibt einen Zeichenausdruck zurück, nachdem Großbuchstaben in Kleinbuchstaben umgewandelt wurden";
+            case CultureIDs.En_US: return "Returns a character expression after converting all uppercase characters to lowercase";
+            case CultureIDs.Es_ES: return "Devuelve una expresión de caracteres después de haber convertido los caracteres mayúsculos en caracteres minúsculos";
+            case CultureIDs.Fr_FR: return "Retourne un' expression de caractères après la conversion des caractères majuscules en caractères minuscules";
+            case CultureIDs.Pt_PT: return "Retorna uma expressão de caracteres depois de converter letras maiúsculas para minúsculas";
+            default: return "Restituisce un'espressione di caratteri dopo aver convertito i caratteri maiuscoli in caratteri minuscoli";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_LTRIM() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert einen Zeichenausdruck, nachdem die anfänglichen Leerzeichen entfernt wurden";
+            case CultureIDs.En_US: return "Returns a character expression after removing leading spaces";
+            case CultureIDs.Es_ES: return "Devuelve una expresión de caracteres después de haber quitado los espacios vacíos iniciales";
+            case CultureIDs.Fr_FR: return "Renvoie une expression de caractères après avoir enlevé les blancs";
+            case CultureIDs.Pt_PT: return "Retorna uma expressão de caracteres depois de remover espaços no começo";
+            default: return "Restituisce una espressione di caratteri dopo aver rimosso gli spazi vuoti iniziali";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_MONTHGETDATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert den Systemmonat der aktuellen Datenbank als Datumszeitwert ohne die Zeitdifferenz der Datenbank";
+            case CultureIDs.En_US: return "Returns the system month of the current database as a datetime value not considering the time zone difference";
+            case CultureIDs.Es_ES: return "Devuelve el mes del sistema de la base de datos actual como valor datetime sin la diferencia de huso horario de la base de datos";
+            case CultureIDs.Fr_FR: return "Renvoie le mois du système de base de données actuelle comme une valeur datetime sans la différence fuseau horaire de base de données de zone";
+            case CultureIDs.Pt_PT: return "Retorna o mês do atual sistema de banco de dados como um valor de data e hora, sem a diferença de tempo de banco de dados";
+            default: return "Restituisce il mese di sistema del database corrente come valore datetime senza la differenza di fuso orario del database";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_REPLACE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ersetzt alle Vorkommen eines angegebenen Zeichenkettenwertes durch einen anderen Zeichenkettenwert";
+            case CultureIDs.En_US: return "Replaces all occurences of a specified string value with another string value";
+            case CultureIDs.Es_ES: return "Sustituye todas las veces que aparece un valor de cadena especificado con otro valor de cadena";
+            case CultureIDs.Fr_FR: return "Remplace toutes les occurrences d'une valeur de chaîne spécifiée avec une autre valeur de chaîne";
+            case CultureIDs.Pt_PT: return "Substitui todas as ocorrências de um valor de cadeia especificado com outro valor de cadeia";
+            default: return "Sostituisce tutte le occorrenze di un valore stringa specificato con un altro valore stringa";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_REPLICATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Wiederholt eine Wertzeichenkette so oft, wie angegeben";
+            case CultureIDs.En_US: return "Repeats a srting value for a number of specified times";
+            case CultureIDs.Es_ES: return "Repite un valor de cadena el número de veces especificado";
+            case CultureIDs.Fr_FR: return "Répète une valeur de chaîne d'un certain nombre de fois";
+            case CultureIDs.Pt_PT: return "Repete um valor de seqüência o número de vezes";
+            default: return "Ripete un valore stringa il numero di volte specificato";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_RIGHT() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert den letzten Teil einer Zeichenkette, der gleich lang wie die angegebene Anzahl von Zeichen ist";
+            case CultureIDs.En_US: return "Returns the end part of a string, its length the number of characters specified";
+            case CultureIDs.Es_ES: return "Devuelve la parte final de una cadena de caracteres, de longitud igual al número de caracteres especificado";
+            case CultureIDs.Fr_FR: return "Renvoie la fin d'une chaîne de caractères de longueur égale au nombre de caractères spécifié";
+            case CultureIDs.Pt_PT: return "Retorna a parte final de uma cadeia de caracteres, de comprimento igual ao número especificado de caracteres";
+            default: return "Restituisce la parte finale di una stringa di caratteri, di lunghezza pari al numero di caratteri specificato";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_RTRIM() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Gibt eine Zeichenkette zurück, nachdem alle letzten Leerzeichen entfernt wurden";
+            case CultureIDs.En_US: return "Returns a string after removing all trailing spaces";
+            case CultureIDs.Es_ES: return "Devuelve una cadena de caracteres después de quitar todos los espacios vacíos finales";
+            case CultureIDs.Fr_FR: return "Retourne une chaîne de caractères après avoir enlevé tous les espaces à droite";
+            case CultureIDs.Pt_PT: return "Retorna uma cadeia de caracteres após a remoção de todos os espaços em branco finais";
+            default: return "Restituisce una stringa di caratteri dopo la rimozione di tutti gli spazi vuoti finali";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_SPACE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Gibt eine Zeichenkette von wiederholten Leerzeichen zurück";
+            case CultureIDs.En_US: return "Retrurns a repeated spaces string";
+            case CultureIDs.Es_ES: return "Devuelve una cadena de espacios repetidos";
+            case CultureIDs.Fr_FR: return "Retourne une chaîne d'espaces répétés";
+            case CultureIDs.Pt_PT: return "Retorna uma seqüência de espaços repetidas";
+            default: return "Restituisce una stringa di spazi ripetuti";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_STUFF() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Die Funktion STUFF ermöglicht es Ihnen, eine Zeichenkette in eine andere Zeichenkette einzufügen, indem Sie eine Anzahl von Zeichen löschen, die an der Anfangsposition der ersten Zeichenkette angegeben sind, und die zweite Zeichenkette an dieser Position einfügen";
+            case CultureIDs.En_US: return "STUFF function allows adding a string within another by removing a specified number of characters and adding the second string in that position";
+            case CultureIDs.Es_ES: return "La función STUFF permite introducir una cadena en otra cadena eliminando un número de caracteres especificado en la posición inicial de la primera cadena e introduciendo la segunda cadena en esta posición";
+            case CultureIDs.Fr_FR: return "La fonction STUFF insère une chaîne dans une autre chaîne en supprimant un certain nombre de caractères dans la position initiale de la première chaîne et l'insertion de la deuxième chaîne dans cette position";
+            case CultureIDs.Pt_PT: return "Função STUFF insere uma seqüência de caracteres em outra cadeia por exclusão de um número especificado de caracteres na posição inicial da primeira corda, e inserindo a segunda cadeia nesta posição";
+            default: return "La funzione STUFF consente di inserire una stringa in un'altra stringa eliminando un numero di caratteri specificato nella posizione iniziale della prima stringa e inserendo la seconda stringa in tale posizione";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_SUBSTRING() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert einen Teil eines Zeichen-, Binär-, Text- oder Bildtyp-Ausdrucks";
+            case CultureIDs.En_US: return "Returns a part of a character binary, text or image";
+            case CultureIDs.Es_ES: return "Devuelve parte de una expresión de tipo carácter, binario, texto o imagen";
+            case CultureIDs.Fr_FR: return "Retourne la partie d'une expression de caractère, binaire, texte ou image";
+            case CultureIDs.Pt_PT: return "Retorna parte de uma expressão do caráter, binário, texto ou imagem";
+            default: return "Restituisce parte di un'espressione di tipo carattere, binario, testo o immagine";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_UPPER() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert einen Ausdruck von Zeichen mit Daten vom Typ Kleinbuchstaben, die in Großbuchstaben umgewandelt wurden";
+            case CultureIDs.En_US: return "Returns a character expression after converting all lowercase characters to uppercase";
+            case CultureIDs.Es_ES: return "Devuelve una expresión de caracteres con datos de tipo carácter minúsculo convertidos en mayúsculo";
+            case CultureIDs.Fr_FR: return "Renvoie une expression de caractères avec les données de caractères minuscules ont été convertis en majuscules";
+            case CultureIDs.Pt_PT: return "Retorna uma expressão de caracteres com dados de caracteres em minúsculas convertidos em maiúsculas";
+            default: return "Restituisce un'espressione di caratteri con dati di tipo carattere minuscoli convertiti in maiuscolo";
+        }
+    }
+    static get FormulaEditor_DescFunction_SS_YEARGETDATE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Liefert das Systemjahr der aktuellen Datenbank als Datumszeitwert ohne die Zeitzonendifferenz der Datenbank";
+            case CultureIDs.En_US: return "Returns the system year of the current database as a datetime value not considering the time zone difference";
+            case CultureIDs.Es_ES: return "Devuelve el año del sistema de la base de datos actual como valor datetime sin la diferencia de huso horario de la base de datos";
+            case CultureIDs.Fr_FR: return "Renvoie l'année du système en tant que valeur datetime actuelle sans la différence de temps de base de données de la zone de base de données";
+            case CultureIDs.Pt_PT: return "Retorna o ano do atual sistema de banco de dados como um valor de data e hora, sem a diferença de tempo de banco de dados";
+            default: return "Restituisce l'anno di sistema del database corrente come valore datetime senza la differenza di fuso orario del database";
+        }
+    }
+    static get FormulaEditor_DescInstruction_SS_CASE() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Bewertet eine Liste von Bedingungen und gibt einen von so vielen Ergebnisausdrücken wie möglich zurück";
+            case CultureIDs.En_US: return "Evaluates a condition list and returns one among the featured possible result expressions";
+            case CultureIDs.Es_ES: return "Valora una lista de condiciones y devuelve una entre las expresiones de resultado posibles";
+            case CultureIDs.Fr_FR: return "Évalue une liste de conditions et renvoie l'une des multiples expressions de résultats possibles";
+            case CultureIDs.Pt_PT: return "Reveja a lista de condições e retorna uma das múltiplas expressões resultado possível";
+            default: return "Valuta un elenco di condizioni e restituisce una tra più espressioni di risultato possibili";
+        }
+    }
+    static get FormulaEditor_DescInstruction_SS_CONVERT() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Konvertiert einen Ausdruck von einem Datentyp in einen anderen";
+            case CultureIDs.En_US: return "Converts an expression from one data type to another";
+            case CultureIDs.Es_ES: return "Convertir una expresión de un tipo de datos a otro";
+            case CultureIDs.Fr_FR: return "Conversion d'une expression d'un type de données à un autre";
+            case CultureIDs.Pt_PT: return "Converter uma expressão de um tipo de dados para outro";
+            default: return "Converte un'espressione da un tipo di dati a un altro";
+        }
+    }
+    static get FormulaEditor_DescInstruction_SS_CONVERTint() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Konvertiert einen Ausdruck von einem Datentyp nach INT";
+            case CultureIDs.En_US: return "Converts an expression from one data type to INT";
+            case CultureIDs.Es_ES: return "Convertir una expresión de un tipo de datos a INT";
+            case CultureIDs.Fr_FR: return "Conversion d'une expression d'un type de données à INT";
+            case CultureIDs.Pt_PT: return "Converter uma expressão de um tipo de dados para INT";
+            default: return "Converte un'espressione da un tipo di dati a INT";
+        }
+    }
+    static get FormulaEditor_DescInstruction_SS_CONVERTnvarchar() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Konvertiert einen Ausdruck von einem Datentyp nach NVARCHAR";
+            case CultureIDs.En_US: return "Converts an expression from one data type to  NVARCHAR";
+            case CultureIDs.Es_ES: return "Convertir una expresión de un tipo de datos a NVARCHAR";
+            case CultureIDs.Fr_FR: return "Conversion d'une expression d'un type de données à NVARCHAR";
+            case CultureIDs.Pt_PT: return "Converter uma expressão de um tipo de dados para NVARCHAR";
+            default: return "Converte un'espressione da un tipo di dati a NVARCHAR";
+        }
+    }
+    static get FormulaEditor_DescInstruction_SS_ISNULL() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ersetzt NULL durch den angegebenen Ersatzwert";
+            case CultureIDs.En_US: return "Replaces NULL with the specified substituting value";
+            case CultureIDs.Es_ES: return "Sustituir NULL con el valor de sustitución especificado";
+            case CultureIDs.Fr_FR: return "Remplace NULL à la valeur de remplacement spécifiée";
+            case CultureIDs.Pt_PT: return "Substitua NULL com o valor de substituição especificado";
+            default: return "Sostituisce NULL con il valore di sostituzione specificato";
+        }
+    }
+    static get FormulaEditor_DescInstruction_SS_IS_NULL() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Legt fest, ob ein angegebener Ausdruck NULL ist";
+            case CultureIDs.En_US: return "Determines whether a specified expression is NULL";
+            case CultureIDs.Es_ES: return "Determinar si una expresión especificada en NULL";
+            case CultureIDs.Fr_FR: return "Détermine si une expression spécifiée est NULL";
+            case CultureIDs.Pt_PT: return "Determina se a expressão especificada é NULL";
+            default: return "Determina se un'espressione specificata è NULL";
+        }
+    }
+    static get FormulaEditor_DescFunction_TM_GetViewLink_WithDate() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Erzeugt einen Anzeige-Link, der 30 Tage nach dem Speicherdatum abläuft";
+            case CultureIDs.En_US: return "Generates a link display that expires 30 days after the date of filing";
+            case CultureIDs.Es_ES: return "Generar un enlace de visualización que finalice 30 días después de la fecha de almacenamiento";
+            case CultureIDs.Fr_FR: return "Crée un link de visualisation qui  expire 30 jours après la date d'archivage";
+            case CultureIDs.Pt_PT: return "Gera uma exibição link que expira 30 dias após a data do depósito";
+            default: return "Genera un link di visualizzazione che scade 30 giorni dopo la data di archiviazione";
+        }
+    }
+    static get FormulaEditor_DescFunction_TM_GetViewLink_WithLogin() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Erzeugt einen Visualisierungslink mit Anmeldeanforderung an den Benutzer";
+            case CultureIDs.En_US: return "Generates a link display with requiring the login";
+            case CultureIDs.Es_ES: return "Generar un enlace de visualización con solicitud de credenciales al usuario";
+            case CultureIDs.Fr_FR: return "Crée un link de visualisation avec l'identification de l'utilisateur";
+            case CultureIDs.Pt_PT: return "Gera uma exibição ligação com pedido de credenciais de usuário";
+            default: return "Genera un link di visualizzazione con richiesta di credenziali all'utente";
+        }
+    }
+    static get FormulaEditor_DescFunction_TM_GetViewLink_WithoutLogin() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Erzeugt eine Visualisierungsverbindung, ohne dass der Benutzer Anmeldeinformationen benötigt";
+            case CultureIDs.En_US: return "Generates a link display without a request for the";
+            case CultureIDs.Es_ES: return "Generar un enlace de visualización sin solicitud de credenciales al usuario";
+            case CultureIDs.Fr_FR: return "Crée un link de visualisation sans l'identification de l'utilisateur";
+            case CultureIDs.Pt_PT: return "Gera uma exibição do link, sem exigir credenciais de usuário";
+            default: return "Genera un link di visualizzazione senza richiesta di credenziali all'utente";
+        }
+    }
+    //=============
     static get File_Downloading() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Datei wird heruntergeladen";
@@ -6452,6 +6964,16 @@ export class SDKUI_Localizator {
             default: return "Cambia utente";
         }
     }
+    static get SystemUser() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Systembenutzer";
+            case CultureIDs.En_US: return "System user";
+            case CultureIDs.Es_ES: return "Usuario del sistema";
+            case CultureIDs.Fr_FR: return "Utilisateur système";
+            case CultureIDs.Pt_PT: return "Usuário do sistema";
+            default: return "Utente di sistema";
+        }
+    }
     static get TargetedSearch() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Gezielte Suche";