@topconsultnpm/sdkui-react 6.21.0-dev2.9 → 6.21.0-dev3.11

package/lib/helper/SDKUI_Localizator.js

@@ -484,6 +484,26 @@ 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 ArchivingCompletionInProgress() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Archivierung wird abgeschlossen";
+            case CultureIDs.En_US: return "Completing archiving";
+            case CultureIDs.Es_ES: return "Completando archivación";
+            case CultureIDs.Fr_FR: return "Finalisation de l'archivage";
+            case CultureIDs.Pt_PT: return "Concluindo arquivamento";
+            default: return "Completamento archiviazione in corso";
+        }
+    }
     static get Arguments() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Themen";
@@ -765,6 +785,26 @@ export class SDKUI_Localizator {
             default: return "Sfoglia le cartelle nelle aree di appoggio";
         }
     }
+    static get BrowserDoesNotSupportFolderSelection() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Der verwendete Browser unterstützt die Ordnerauswahl nicht";
+            case CultureIDs.En_US: return "The browser in use does not support folder selection";
+            case CultureIDs.Es_ES: return "El navegador en uso no admite la selección de carpetas";
+            case CultureIDs.Fr_FR: return "Le navigateur utilisé ne prend pas en charge la sélection de dossier";
+            case CultureIDs.Pt_PT: return "O navegador utilizado não suporta a seleção de pastas";
+            default: return "Il browser in uso non supporta la selezione della cartella";
+        }
+    }
+    static get BrowserAutoRenamesDuplicateFilesInDownloadsFolder() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Browser benennt Duplikate automatisch um";
+            case CultureIDs.En_US: return "Browser auto-renames duplicate files";
+            case CultureIDs.Es_ES: return "El navegador renombra archivos duplicados";
+            case CultureIDs.Fr_FR: return "Le navigateur renomme les fichiers en double";
+            case CultureIDs.Pt_PT: return "O navegador renomeia ficheiros duplicados";
+            default: return "Il browser rinomina automaticamente i file duplicati";
+        }
+    }
     static get ByDate() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Bis zum";
@@ -805,6 +845,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 +1040,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";
@@ -1020,6 +1080,16 @@ export class SDKUI_Localizator {
             default: return "Chiudi attività";
         }
     }
+    static get CollapseAll() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Alle reduzieren";
+            case CultureIDs.En_US: return "Collapse all";
+            case CultureIDs.Es_ES: return "Contraer todo";
+            case CultureIDs.Fr_FR: return "Tout réduire";
+            case CultureIDs.Pt_PT: return "Recolher tudo";
+            default: return "Comprimi tutto";
+        }
+    }
     static get Columns_All_Hide() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Alle Spalten ausblenden";
@@ -1110,6 +1180,26 @@ export class SDKUI_Localizator {
             default: return "Errore completo";
         }
     }
+    static get CompressToZipFile() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "In eine ZIP-Datei komprimieren";
+            case CultureIDs.En_US: return "Compress into a ZIP file";
+            case CultureIDs.Es_ES: return "Comprimir en un archivo ZIP";
+            case CultureIDs.Fr_FR: return "Compresser dans un fichier ZIP";
+            case CultureIDs.Pt_PT: return "Comprimir em um ficheiro ZIP";
+            default: return "Comprimi in un file zip";
+        }
+    }
+    static get ConfigurationParameters() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Konfigurationsparameter";
+            case CultureIDs.En_US: return "Configuration parameters";
+            case CultureIDs.Es_ES: return "Parámetros de configuración";
+            case CultureIDs.Fr_FR: return "Paramètres de configuration";
+            case CultureIDs.Pt_PT: return "Parâmetros de configuração";
+            default: return "Parametri di configurazione";
+        }
+    }
     static get Configure() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Konfigurieren";
@@ -1236,6 +1326,26 @@ export class SDKUI_Localizator {
             default: return "Copia";
         }
     }
+    static get CopyAndReplace() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Kopieren und ersetzen";
+            case CultureIDs.En_US: return "Copy and replace";
+            case CultureIDs.Es_ES: return "Copiar y reemplazar";
+            case CultureIDs.Fr_FR: return "Copier et remplacer";
+            case CultureIDs.Pt_PT: return "Copiar e substituir";
+            default: return "Copia e sostituisci";
+        }
+    }
+    static get CopyButRename() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Kopieren, aber umbenennen";
+            case CultureIDs.En_US: return "Copy, but rename";
+            case CultureIDs.Es_ES: return "Copiar, pero renombrar";
+            case CultureIDs.Fr_FR: return "Copier, mais renommer";
+            case CultureIDs.Pt_PT: return "Copiar, mas renomear";
+            default: return "Copia, ma rinomina";
+        }
+    }
     static get CopyCheckoutPath() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Checkout-Pfad kopieren";
@@ -1286,6 +1396,16 @@ export class SDKUI_Localizator {
             default: return "Copia nelle bozze";
         }
     }
+    static get CopyToFolder() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "In einen Ordner kopieren";
+            case CultureIDs.En_US: return "Copy to a folder";
+            case CultureIDs.Es_ES: return "Copiar en una carpeta";
+            case CultureIDs.Fr_FR: return "Copier dans un dossier";
+            case CultureIDs.Pt_PT: return "Copiar para uma pasta";
+            default: return "Copia in una cartella";
+        }
+    }
     static get CopyUserInfo() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Benutzerinfo kopieren";
@@ -1939,6 +2059,46 @@ export class SDKUI_Localizator {
             default: return "Operazioni sui documenti";
         }
     }
+    static get DocumentTypeNameAndDID() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dokumenttypname und DID";
+            case CultureIDs.En_US: return "Document type name and DID";
+            case CultureIDs.Es_ES: return "Nombre del tipo de documento y DID";
+            case CultureIDs.Fr_FR: return "Nom du type de document et DID";
+            case CultureIDs.Pt_PT: return "Nome do tipo de documento e DID";
+            default: return "Nome tipo documento e DID";
+        }
+    }
+    static get DocumentTypeNameAndCustomMetadata() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dokumenttypname und benutzerdefinierte Metadaten";
+            case CultureIDs.En_US: return "Document type name and custom metadata";
+            case CultureIDs.Es_ES: return "Nombre del tipo de documento y metadatos personalizados";
+            case CultureIDs.Fr_FR: return "Nom du type de document et métadonnées personnalisées";
+            case CultureIDs.Pt_PT: return "Nome do tipo de documento e metadados personalizados";
+            default: return "Nome tipo documento e metadati personalizzati";
+        }
+    }
+    static get DocumentWillBeConvertedDuringMerge() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ein Dokument{{0}} wird während der Zusammenführung in PDF konvertiert";
+            case CultureIDs.En_US: return "One document{{0}} will be converted to PDF during the merge";
+            case CultureIDs.Es_ES: return "Un documento{{0}} se convertirá a PDF durante la unión";
+            case CultureIDs.Fr_FR: return "Un document{{0}} sera converti en PDF lors de la fusion";
+            case CultureIDs.Pt_PT: return "Um documento{{0}} será convertido em PDF durante a fusão";
+            default: return "Un documento{{0}} verrà convertito in PDF durante l'unione";
+        }
+    }
+    static get DocumentsWillBeConvertedDuringMerge() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "{{0}} Dokumente{{1}} werden während der Zusammenführung in PDF konvertiert";
+            case CultureIDs.En_US: return "{{0}} documents{{1}} will be converted to PDF during the merge";
+            case CultureIDs.Es_ES: return "{{0}} documentos{{1}} se convertirán a PDF durante la unión";
+            case CultureIDs.Fr_FR: return "{{0}} documents{{1}} seront convertis en PDF lors de la fusion";
+            case CultureIDs.Pt_PT: return "{{0}} documentos{{1}} serão convertidos em PDF durante a fusão";
+            default: return "{{0}} documenti{{1}} verranno convertiti in PDF durante l'unione";
+        }
+    }
     static get Domain() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Domäne";
@@ -1949,6 +2109,16 @@ export class SDKUI_Localizator {
             default: return "Dominio";
         }
     }
+    static get DoNotCopy() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Nicht kopieren";
+            case CultureIDs.En_US: return "Do not copy";
+            case CultureIDs.Es_ES: return "No copiar";
+            case CultureIDs.Fr_FR: return "Ne pas copier";
+            case CultureIDs.Pt_PT: return "Não copiar";
+            default: return "Non copiare";
+        }
+    }
     static get Dossier() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Übung";
@@ -2029,6 +2199,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";
@@ -2327,6 +2507,16 @@ export class SDKUI_Localizator {
             default: return "Errore nelle date (1)";
         }
     }
+    static get Execute() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ausführen";
+            case CultureIDs.En_US: return "Run";
+            case CultureIDs.Es_ES: return "Ejecutar";
+            case CultureIDs.Fr_FR: return "Exécuter";
+            case CultureIDs.Pt_PT: return "Executar";
+            default: return "Esegui";
+        }
+    }
     static get ExecuteCancelCheckOutQuestion() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Check-out abbrechen?";
@@ -2367,6 +2557,16 @@ export class SDKUI_Localizator {
             default: return "Esporta solo i documenti selezionati";
         }
     }
+    static get ExportModeNotSupported() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Exportmodus nicht unterstützt";
+            case CultureIDs.En_US: return "Export mode not supported";
+            case CultureIDs.Es_ES: return "Modo de exportación no compatible";
+            case CultureIDs.Fr_FR: return "Mode d'exportation non pris en charge";
+            case CultureIDs.Pt_PT: return "Modo de exportação não suportado";
+            default: return "Modalità di esportazione non supportata";
+        }
+    }
     static get ExportSelectedColumnsAndFormatLabel() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return 'Exportiere die Spalten "Auswahl" und "Format"';
@@ -2417,6 +2617,16 @@ export class SDKUI_Localizator {
             default: return "Valuta il risultato";
         }
     }
+    static get ExpandAll() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Alle erweitern";
+            case CultureIDs.En_US: return "Expand all";
+            case CultureIDs.Es_ES: return "Expandir todo";
+            case CultureIDs.Fr_FR: return "Tout développer";
+            case CultureIDs.Pt_PT: return "Expandir tudo";
+            default: return "Espandi tutto";
+        }
+    }
     static get Expected() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Erwartet";
@@ -2647,6 +2857,26 @@ export class SDKUI_Localizator {
             default: return "La destinazione contiene {{0}} file con lo stesso nome, sostituire con i nuovi file?";
         }
     }
+    static get FileNotPdfWillBeExcluded() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ein Dokument ist nicht im PDF-Format{{0}} und wird vom Zusammenführen ausgeschlossen.";
+            case CultureIDs.En_US: return "One document is not in PDF format{{0}} and will be excluded from the merge.";
+            case CultureIDs.Es_ES: return "Un documento no está en formato PDF{{0}} y será excluido de la unión.";
+            case CultureIDs.Fr_FR: return "Un document n'est pas au format PDF{{0}} et sera exclu de la fusion.";
+            case CultureIDs.Pt_PT: return "Um documento não está em formato PDF{{0}} e será excluído da fusão.";
+            default: return "Un documento non è in formato PDF{{0}} e sarà escluso dall'unione.";
+        }
+    }
+    static get FilesNotPdfWillBeExcluded() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "{{0}} Dokumente sind nicht im PDF-Format{{1}} und werden vom Zusammenführen ausgeschlossen.";
+            case CultureIDs.En_US: return "{{0}} documents are not in PDF format{{1}} and will be excluded from the merge.";
+            case CultureIDs.Es_ES: return "{{0}} documentos no están en formato PDF{{1}} y serán excluidos de la unión.";
+            case CultureIDs.Fr_FR: return "{{0}} documents ne sont pas au format PDF{{1}} et seront exclus de la fusion.";
+            case CultureIDs.Pt_PT: return "{{0}} documentos não estão em formato PDF{{1}} e serão excluídos da fusão.";
+            default: return "{{0}} documenti non sono in formato PDF{{1}} e saranno esclusi dall'unione.";
+        }
+    }
     static get FileUpload() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Datei hochladen";
@@ -2667,6 +2897,16 @@ export class SDKUI_Localizator {
             default: return "Cartella";
         }
     }
+    static get FolderName() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ordnername";
+            case CultureIDs.En_US: return "Folder name";
+            case CultureIDs.Es_ES: return "Nombre de carpeta";
+            case CultureIDs.Fr_FR: return "Nom du dossier";
+            case CultureIDs.Pt_PT: return "Nome da pasta";
+            default: return "Nome cartella";
+        }
+    }
     static get FolderExist() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ordner existiert bereits. Bitte versuchen Sie einen anderen Namen";
@@ -2847,6 +3087,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";
@@ -3827,6 +4539,26 @@ export class SDKUI_Localizator {
             default: return "Metadati utente";
         }
     }
+    static get MergeFilesToPdf() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "{{0}} Dateien zu PDF zusammenführen";
+            case CultureIDs.En_US: return "Merge {{0}} files into PDF";
+            case CultureIDs.Es_ES: return "Unir {{0}} archivos en PDF";
+            case CultureIDs.Fr_FR: return "Fusionner {{0}} fichiers en PDF";
+            case CultureIDs.Pt_PT: return "Unir {{0}} ficheiros em PDF";
+            default: return "Unisci {{0}} file in PDF";
+        }
+    }
+    static get MergeToPdf() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "In PDF zusammenführen";
+            case CultureIDs.En_US: return "Merge into PDF";
+            case CultureIDs.Es_ES: return "Unir en PDF";
+            case CultureIDs.Fr_FR: return "Fusionner en PDF";
+            case CultureIDs.Pt_PT: return "Unir em PDF";
+            default: return "Unisci in PDF";
+        }
+    }
     static get Message() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Nachricht";
@@ -4128,6 +4860,16 @@ export class SDKUI_Localizator {
             default: return "Nessun documento selezionato per l'abbinamento molti a molti.";
         }
     }
+    static get NoDocumentsSelected() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Keine Dokumente ausgewählt";
+            case CultureIDs.En_US: return "No documents selected";
+            case CultureIDs.Es_ES: return "Ningún documento seleccionado";
+            case CultureIDs.Fr_FR: return "Aucun document sélectionné";
+            case CultureIDs.Pt_PT: return "Nenhum documento selecionado";
+            default: return "Nessun documento selezionato";
+        }
+    }
     static get NoDocumentSelectedForManyToManyUnmatching() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Kein Dokument für die Aufhebung der Mehrfach-Zuordnung ausgewählt.";
@@ -4148,6 +4890,16 @@ export class SDKUI_Localizator {
             default: return "Nessun documento da abbinare. Tutti i documenti risultanti sono già abbinati.";
         }
     }
+    static get NoFilesAvailableForMerge() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Keine Dateien zum Zusammenführen verfügbar";
+            case CultureIDs.En_US: return "No files available for merging";
+            case CultureIDs.Es_ES: return "No hay archivos disponibles para la unión";
+            case CultureIDs.Fr_FR: return "Aucun fichier disponible pour la fusion";
+            case CultureIDs.Pt_PT: return "Não há ficheiros disponíveis para a fusão";
+            default: return "Nessun file disponibile per l'unione";
+        }
+    }
     static get NoManyToManyMatchingRelationshipAssociatedWithRetrievalQuery() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Keine Mehrfach-Zuordnungsbeziehung mit Abrufabfrage verknüpft.";
@@ -4268,6 +5020,26 @@ export class SDKUI_Localizator {
             default: return "Nessun pannello selezionato";
         }
     }
+    static get NoPdfOrConvertibleFilesSelected_Param() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Keine PDF- oder konvertierbaren Dateien unter den ausgewählten: mindestens {{0}} erforderlich";
+            case CultureIDs.En_US: return "No PDF or convertible files among the selected items: at least {{0}} are required";
+            case CultureIDs.Es_ES: return "Ningún archivo PDF o convertible entre los seleccionados: se necesitan al menos {{0}}";
+            case CultureIDs.Fr_FR: return "Aucun fichier PDF ou convertible parmi les éléments sélectionnés : au moins {{0}} requis";
+            case CultureIDs.Pt_PT: return "Nenhum ficheiro PDF ou convertível entre os selecionados: são necessários pelo menos {{0}}";
+            default: return "Nessun file PDF o convertibile tra i selezionati: ne servono almeno {{0}}";
+        }
+    }
+    static get NoPdfOrConvertibleFilesAmongSelectedMergeBlocked() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Unter den ausgewählten Dokumenten befindet sich keine PDF- oder konvertierbare Datei: die Zusammenführung kann nicht ausgeführt werden";
+            case CultureIDs.En_US: return "No PDF or convertible file is present among the selected documents: the merge cannot be performed";
+            case CultureIDs.Es_ES: return "Entre los documentos seleccionados no hay ningún archivo PDF o convertible a PDF: la unión no puede realizarse";
+            case CultureIDs.Fr_FR: return "Parmi les documents sélectionnés, aucun fichier PDF ou convertible en PDF n'est présent : la fusion ne peut pas être effectuée";
+            case CultureIDs.Pt_PT: return "Entre os documentos selecionados não existe nenhum ficheiro PDF ou convertível em PDF: a fusão não pode ser executada";
+            default: return "Tra i documenti selezionati non è presente alcun file PDF o convertibile in PDF: l'unione non può essere eseguita";
+        }
+    }
     static get NoResultsFound() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Kein Ergebnis gefunden";
@@ -4318,6 +5090,26 @@ export class SDKUI_Localizator {
             default: return "Non disponibile";
         }
     }
+    static get Note() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Hinweis";
+            case CultureIDs.En_US: return "Note";
+            case CultureIDs.Es_ES: return "Nota";
+            case CultureIDs.Fr_FR: return "Remarque";
+            case CultureIDs.Pt_PT: return "Nota";
+            default: return "Nota";
+        }
+    }
+    static get NotesAndWarnings() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Hinweise und Warnungen";
+            case CultureIDs.En_US: return "Notes and Warnings";
+            case CultureIDs.Es_ES: return "Notas y advertencias";
+            case CultureIDs.Fr_FR: return "Notes et avertissements";
+            case CultureIDs.Pt_PT: return "Notas e avisos";
+            default: return "Note e avvisi";
+        }
+    }
     static get MaximumNumberOfResults() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Maximale Anzahl von Ergebnissen";
@@ -4418,6 +5210,46 @@ export class SDKUI_Localizator {
             default: return "altro";
         }
     }
+    static get OnlyCustomMetadata() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Nur benutzerdefinierte Metadaten";
+            case CultureIDs.En_US: return "Custom metadata only";
+            case CultureIDs.Es_ES: return "Solo metadatos personalizados";
+            case CultureIDs.Fr_FR: return "Métadonnées personnalisées uniquement";
+            case CultureIDs.Pt_PT: return "Apenas metadados personalizados";
+            default: return "Solo metadati personalizzati";
+        }
+    }
+    static get OnlyDID() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Nur DID";
+            case CultureIDs.En_US: return "DID only";
+            case CultureIDs.Es_ES: return "Solo DID";
+            case CultureIDs.Fr_FR: return "DID uniquement";
+            case CultureIDs.Pt_PT: return "Apenas DID";
+            default: return "Solo DID";
+        }
+    }
+    static get OnlyOnePdfOrConvertibleFileSelected() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Nur 1 PDF- oder konvertierbare Datei unter den ausgewählten: mindestens {{0}} erforderlich";
+            case CultureIDs.En_US: return "Only 1 PDF or convertible file among the selected items: at least {{0}} are required";
+            case CultureIDs.Es_ES: return "Solo 1 archivo PDF o convertible entre los seleccionados: se necesitan al menos {{0}}";
+            case CultureIDs.Fr_FR: return "Seulement 1 fichier PDF ou convertible parmi les éléments sélectionnés : au moins {{0}} requis";
+            case CultureIDs.Pt_PT: return "Apenas 1 ficheiro PDF ou convertível entre os selecionados: são necessários pelo menos {{0}}";
+            default: return "Solo 1 file PDF o convertibile tra i selezionati: ne servono almeno {{0}}";
+        }
+    }
+    static get OnlyOnePdfOrConvertibleFileMergeBlocked() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Unter den ausgewählten Dokumenten befindet sich nur eine PDF- oder konvertierbare Datei: für die Zusammenführung sind mindestens {{0}} erforderlich";
+            case CultureIDs.En_US: return "Only one PDF or convertible file is present among the selected documents: at least {{0}} are required for merging";
+            case CultureIDs.Es_ES: return "Entre los documentos seleccionados solo hay un archivo PDF o convertible: para la unión se necesitan al menos {{0}}";
+            case CultureIDs.Fr_FR: return "Parmi les documents sélectionnés, il n'y a qu'un seul fichier PDF ou convertible : au moins {{0}} sont requis pour la fusion";
+            case CultureIDs.Pt_PT: return "Entre os documentos selecionados existe apenas um ficheiro PDF ou convertível: para a fusão são necessários pelo menos {{0}}";
+            default: return "Tra i documenti selezionati è presente un solo file PDF o convertibile: per l'unione ne servono almeno {{0}}";
+        }
+    }
     static get OperationFilesInterrupted() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return `Vorgang unterbrochen. {{0}} Dateien verarbeitet`;
@@ -4588,6 +5420,16 @@ export class SDKUI_Localizator {
             default: return "Non proprietario";
         }
     }
+    static get IfFileExists() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Wenn die Datei existiert";
+            case CultureIDs.En_US: return "If the file exists";
+            case CultureIDs.Es_ES: return "Si el archivo existe";
+            case CultureIDs.Fr_FR: return "Si le fichier existe";
+            case CultureIDs.Pt_PT: return "Se o ficheiro existir";
+            default: return "Se il file esiste";
+        }
+    }
     static get Path() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Dateipfad";
@@ -4820,22 +5662,22 @@ export class SDKUI_Localizator {
     }
     static get PasswordRule_Uppercase() {
         switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Großbuchstaben (A–Z).";
-            case CultureIDs.En_US: return "Uppercase character (A–Z).";
-            case CultureIDs.Es_ES: return "Letra mayúscula (A–Z).";
-            case CultureIDs.Fr_FR: return "Caractère majuscule (A–Z).";
-            case CultureIDs.Pt_PT: return "Letra maiúscula (A–Z).";
-            default: return "Lettere maiuscole (A–Z).";
+            case CultureIDs.De_DE: return "Großbuchstaben (A-Z)";
+            case CultureIDs.En_US: return "Uppercase character (A-Z)";
+            case CultureIDs.Es_ES: return "Letra mayúscula (A-Z)";
+            case CultureIDs.Fr_FR: return "Caractère majuscule (A-Z)";
+            case CultureIDs.Pt_PT: return "Letra maiúscula (A-Z)";
+            default: return "Lettere maiuscole (A-Z)";
         }
     }
     static get PasswordRule_Number() {
         switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Zahlen (0–9).";
-            case CultureIDs.En_US: return "Number (0–9).";
-            case CultureIDs.Es_ES: return "Números (0–9).";
-            case CultureIDs.Fr_FR: return "Chiffre (0–9).";
-            case CultureIDs.Pt_PT: return "Números (0–9).";
-            default: return "Numeri (0–9).";
+            case CultureIDs.De_DE: return "Zahlen (0-9)";
+            case CultureIDs.En_US: return "Number (0-9)";
+            case CultureIDs.Es_ES: return "Números (0-9)";
+            case CultureIDs.Fr_FR: return "Chiffre (0-9)";
+            case CultureIDs.Pt_PT: return "Números (0-9)";
+            default: return "Numeri (0-9)";
         }
     }
     static get PasswordRule_Special() {
@@ -4878,6 +5720,22 @@ export class SDKUI_Localizator {
             default: return "Parametri";
         }
     }
+    static get PleaseCorrectErrorsBeforeProceeding() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE:
+                return "Bitte korrigieren Sie die Fehler, bevor Sie fortfahren";
+            case CultureIDs.En_US:
+                return "Please correct the errors before proceeding";
+            case CultureIDs.Es_ES:
+                return "Por favor, corrige los errores antes de continuar";
+            case CultureIDs.Fr_FR:
+                return "Veuillez corriger les erreurs avant de continuer";
+            case CultureIDs.Pt_PT:
+                return "Por favor, corrija os erros antes de prosseguir";
+            default:
+                return "Per favore, correggi gli errori prima di procedere";
+        }
+    }
     static get PDFDocument() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "PDF-Dokument";
@@ -4888,6 +5746,46 @@ export class SDKUI_Localizator {
             default: return "Documento PDF";
         }
     }
+    static get PdfFileName() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "PDF-Dateiname";
+            case CultureIDs.En_US: return "PDF file name";
+            case CultureIDs.Es_ES: return "Nombre del archivo PDF";
+            case CultureIDs.Fr_FR: return "Nom du fichier PDF";
+            case CultureIDs.Pt_PT: return "Nome do ficheiro PDF";
+            default: return "Nome file PDF";
+        }
+    }
+    static get PdfMergeError() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Fehler beim Zusammenführen der PDF- oder konvertierbaren Dateien";
+            case CultureIDs.En_US: return "Error merging PDF or convertible files";
+            case CultureIDs.Es_ES: return "Error al combinar archivos PDF o convertibles";
+            case CultureIDs.Fr_FR: return "Erreur lors de la fusion des fichiers PDF ou convertibles";
+            case CultureIDs.Pt_PT: return "Erro ao unir ficheiros PDF ou convertíveis";
+            default: return "Errore durante l'unione dei file PDF o convertibili";
+        }
+    }
+    static get PdfMergeFeatureNotAvailable() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Die PDF-Zusammenführungsfunktion ist nicht verfügbar";
+            case CultureIDs.En_US: return "The PDF merge feature is not available";
+            case CultureIDs.Es_ES: return "La función de unión de PDF no está disponible";
+            case CultureIDs.Fr_FR: return "La fonctionnalité de fusion de PDF n'est pas disponible";
+            case CultureIDs.Pt_PT: return "A funcionalidade de fusão de PDF não está disponível";
+            default: return "La funzionalità di unione PDF non è disponibile";
+        }
+    }
+    static get PdfMergedSavedInFolder() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Die zusammengeführte PDF-Datei wurde im Ordner \"{{0}}\" gespeichert";
+            case CultureIDs.En_US: return "The merged PDF file was saved in the \"{{0}}\" folder";
+            case CultureIDs.Es_ES: return "El archivo PDF combinado se ha guardado en la carpeta \"{{0}}\"";
+            case CultureIDs.Fr_FR: return "Le fichier PDF fusionné a été enregistré dans le dossier \"{{0}}\"";
+            case CultureIDs.Pt_PT: return "O ficheiro PDF combinado foi guardado na pasta \"{{0}}\"";
+            default: return "Il file PDF unito è stato salvato nella cartella \"{{0}}\"";
+        }
+    }
     static get Pending() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ausstehend";
@@ -5054,6 +5952,36 @@ export class SDKUI_Localizator {
             default: return "Legenda delle priorità";
         }
     }
+    static get Print() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Drucken";
+            case CultureIDs.En_US: return "Print";
+            case CultureIDs.Es_ES: return "Imprimir";
+            case CultureIDs.Fr_FR: return "Imprimer";
+            case CultureIDs.Pt_PT: return "Imprimir";
+            default: return "Stampa";
+        }
+    }
+    static get PrintConfirmConversion() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Die Originaldatei kann nicht direkt gedruckt werden und wird in PDF konvertiert.";
+            case CultureIDs.En_US: return "The original file cannot be printed directly and will be converted to PDF.";
+            case CultureIDs.Es_ES: return "El archivo original no se puede imprimir directamente y se convertirá a PDF.";
+            case CultureIDs.Fr_FR: return "Le fichier original ne peut pas être imprimé directement et sera converti en PDF.";
+            case CultureIDs.Pt_PT: return "O arquivo original não pode ser impresso diretamente e será convertido para PDF.";
+            default: return "Il file originale non è stampabile direttamente e verrà convertito in PDF.";
+        }
+    }
+    static get PrintConfirmQuestion() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Möchten Sie mit dem Drucken fortfahren?";
+            case CultureIDs.En_US: return "Do you want to proceed with printing?";
+            case CultureIDs.Es_ES: return "¿Desea continuar con la impresión?";
+            case CultureIDs.Fr_FR: return "Voulez-vous continuer l'impression ?";
+            case CultureIDs.Pt_PT: return "Deseja continuar com a impressão?";
+            default: return "Vuoi procedere con la stampa?";
+        }
+    }
     static get ProceedAnyway() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Dennoch fortfahren?";
@@ -5084,6 +6012,16 @@ export class SDKUI_Localizator {
             default: return "Proprietà";
         }
     }
+    static get ProtectWithPasswordOptional() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Mit Passwort schützen (optional)";
+            case CultureIDs.En_US: return "Protect with password (optional)";
+            case CultureIDs.Es_ES: return "Proteger con contraseña (opcional)";
+            case CultureIDs.Fr_FR: return "Protéger avec un mot de passe (optionnel)";
+            case CultureIDs.Pt_PT: return "Proteger com palavra-passe (opcional)";
+            default: return "Proteggi con password (opzionale)";
+        }
+    }
     static get QueryClear() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Query bereinigen";
@@ -5321,6 +6259,16 @@ export class SDKUI_Localizator {
                 return "Vuoi rimuovere le credenziali '{{0}}' impostate come preferite?";
         }
     }
+    static get RemoveLayout() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Layout entfernen";
+            case CultureIDs.En_US: return "Remove layout";
+            case CultureIDs.Es_ES: return "Eliminar diseño";
+            case CultureIDs.Fr_FR: return "Supprimer la mise en page";
+            case CultureIDs.Pt_PT: return "Remover layout";
+            default: return "Rimuovi Layout";
+        }
+    }
     static get RemovingFromList() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Wird aus der Liste entfernt";
@@ -5331,6 +6279,16 @@ export class SDKUI_Localizator {
             default: return "Rimozione dalla lista in corso";
         }
     }
+    static get RemoveSignatureIfPresent() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Signatur entfernen, falls vorhanden";
+            case CultureIDs.En_US: return "Remove signature if present";
+            case CultureIDs.Es_ES: return "Eliminar la firma si está presente";
+            case CultureIDs.Fr_FR: return "Supprimer la signature si présente";
+            case CultureIDs.Pt_PT: return "Remover assinatura se presente";
+            default: return "Rimuovi la firma se presente";
+        }
+    }
     static get RememberCredentials() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Anmeldedaten merken";
@@ -5541,6 +6499,16 @@ export class SDKUI_Localizator {
             default: return "Ripristinare il commento?";
         }
     }
+    static get Result() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ergebnis";
+            case CultureIDs.En_US: return "Result";
+            case CultureIDs.Es_ES: return "Resultado";
+            case CultureIDs.Fr_FR: return "Résultat";
+            case CultureIDs.Pt_PT: return "Resultado";
+            default: return "Risultato";
+        }
+    }
     static get ResultDetails() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ergebnisdetails";
@@ -5551,6 +6519,16 @@ export class SDKUI_Localizator {
             default: return "Dettagli del risultato";
         }
     }
+    static get RestoreDownload() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Download wiederherstellen";
+            case CultureIDs.En_US: return "Restore download";
+            case CultureIDs.Es_ES: return "Restaurar descarga";
+            case CultureIDs.Fr_FR: return "Restaurer le téléchargement";
+            case CultureIDs.Pt_PT: return "Restaurar download";
+            default: return "Ripristina Download";
+        }
+    }
     static get ResultsPerPage() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ergebnisse pro Seite";
@@ -5611,6 +6589,16 @@ export class SDKUI_Localizator {
             default: return "Salva e chiudi";
         }
     }
+    static get SaveLayout() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Layout speichern";
+            case CultureIDs.En_US: return "Save layout";
+            case CultureIDs.Es_ES: return "Guardar diseño";
+            case CultureIDs.Fr_FR: return "Enregistrer la mise en page";
+            case CultureIDs.Pt_PT: return "Guardar layout";
+            default: return "Salva Layout";
+        }
+    }
     static get SavingInProgress() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Speichern läuft";
@@ -5821,6 +6809,16 @@ export class SDKUI_Localizator {
             default: return "Seleziona dagli allegati";
         }
     }
+    static get SelectFolder() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ordner auswählen";
+            case CultureIDs.En_US: return "Select folder";
+            case CultureIDs.Es_ES: return "Seleccionar carpeta";
+            case CultureIDs.Fr_FR: return "Sélectionner un dossier";
+            case CultureIDs.Pt_PT: return "Selecionar pasta";
+            default: return "Seleziona cartella";
+        }
+    }
     static get SelectMetadata() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Metadaten auswählen";
@@ -5871,6 +6869,26 @@ export class SDKUI_Localizator {
             default: return "Seleziona i filtri desiderati";
         }
     }
+    static get SelectedDocuments() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ausgewählte Dokumente";
+            case CultureIDs.En_US: return "Selected documents";
+            case CultureIDs.Es_ES: return "Documentos seleccionados";
+            case CultureIDs.Fr_FR: return "Documents sélectionnés";
+            case CultureIDs.Pt_PT: return "Documentos selecionados";
+            default: return "I documenti selezionati";
+        }
+    }
+    static get SelectedDocumentsAndRelated() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ausgewählte und zugehörige Dokumente";
+            case CultureIDs.En_US: return "Selected documents and related ones";
+            case CultureIDs.Es_ES: return "Documentos seleccionados y relacionados";
+            case CultureIDs.Fr_FR: return "Documents sélectionnés et associés";
+            case CultureIDs.Pt_PT: return "Documentos selecionados e relacionados";
+            default: return "I documenti selezionati e i correlati";
+        }
+    }
     static get SelectedItems() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ausgewählte Artikel";
@@ -5962,6 +6980,16 @@ export class SDKUI_Localizator {
             default: return "Vuoi impostare le credenziali '{{0}}' come preferite?";
         }
     }
+    static get Separator() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Trennzeichen";
+            case CultureIDs.En_US: return "Separator";
+            case CultureIDs.Es_ES: return "Separador";
+            case CultureIDs.Fr_FR: return "Séparateur";
+            case CultureIDs.Pt_PT: return "Separador";
+            default: return "Separatore";
+        }
+    }
     static get Settings() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Einstellungen";
@@ -6452,6 +7480,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";
@@ -6944,6 +7982,16 @@ export class SDKUI_Localizator {
             default: return "Carica file";
         }
     }
+    static get UseForFileName() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Für den Dateinamen verwenden";
+            case CultureIDs.En_US: return "Use for file name";
+            case CultureIDs.Es_ES: return "Usar para el nombre del archivo";
+            case CultureIDs.Fr_FR: return "Utiliser pour le nom du fichier";
+            case CultureIDs.Pt_PT: return "Usar para o nome do ficheiro";
+            default: return "Per il nome file usa";
+        }
+    }
     static get User_FirstName() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Name";
@@ -7914,6 +8962,26 @@ export class SDKUI_Localizator {
             default: return "Sì";
         }
     }
+    static get ZipFileName() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Name der ZIP-Datei";
+            case CultureIDs.En_US: return "ZIP file name";
+            case CultureIDs.Es_ES: return "Nombre del archivo ZIP";
+            case CultureIDs.Fr_FR: return "Nom du fichier ZIP";
+            case CultureIDs.Pt_PT: return "Nome do ficheiro ZIP";
+            default: return "Nome file zip";
+        }
+    }
+    static get ZipCreatedSavedInFolder() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Die ZIP-Datei {{0}} wurde im Ordner {{1}} gespeichert";
+            case CultureIDs.En_US: return "The ZIP file {{0}} has been saved in the {{1}} folder";
+            case CultureIDs.Es_ES: return "El archivo ZIP {{0}} se ha guardado en la carpeta {{1}}";
+            case CultureIDs.Fr_FR: return "Le fichier ZIP {{0}} a été enregistré dans le dossier {{1}}";
+            case CultureIDs.Pt_PT: return "O ficheiro ZIP {{0}} foi guardado na pasta {{1}}";
+            default: return "Il file ZIP {{0}} è stato salvato nella cartella {{1}}";
+        }
+    }
     static get ZoomIn() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Vergrößern";