@topconsultnpm/sdkui-react 6.22.0-dev3.9 → 6.22.0-dev4.11

package/lib/helper/SDKUI_Localizator.js

@@ -48,6 +48,16 @@ export class SDKUI_Localizator {
             default: return "Interrompere l'elaborazione?";
         }
     }
+    static get Aborting() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Wird gestoppt...";
+            case CultureIDs.En_US: return "Aborting...";
+            case CultureIDs.Es_ES: return "Deteniendo...";
+            case CultureIDs.Fr_FR: return "Arrêt en cours...";
+            case CultureIDs.Pt_PT: return "A parar...";
+            default: return "Interruzione...";
+        }
+    }
     static get About() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Informationen";
@@ -288,6 +298,16 @@ export class SDKUI_Localizator {
             default: return "Tutti gli stati";
         }
     }
+    static get AllowedValuesRange() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zulässige Werte: von {{0}} bis {{1}}";
+            case CultureIDs.En_US: return "Allowed values: from {{0}} to {{1}}";
+            case CultureIDs.Es_ES: return "Valores permitidos: de {{0}} a {{1}}";
+            case CultureIDs.Fr_FR: return "Valeurs autorisées : de {{0}} à {{1}}";
+            case CultureIDs.Pt_PT: return "Valores permitidos: de {{0}} a {{1}}";
+            default: return "Valori consentiti: da {{0}} a {{1}}";
+        }
+    }
     static get Alphabetic() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Alphabetisch";
@@ -298,6 +318,16 @@ export class SDKUI_Localizator {
             default: return "Alfabetico";
         }
     }
+    static get AndOthersCount() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "… und {{0}} weitere";
+            case CultureIDs.En_US: return "… and {{0}} more";
+            case CultureIDs.Es_ES: return "… y {{0}} más";
+            case CultureIDs.Fr_FR: return "… et {{0}} autres";
+            case CultureIDs.Pt_PT: return "… e mais {{0}}";
+            default: return "… e altri {{0}}";
+        }
+    }
     static get Anomalies() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Anomalien";
@@ -2002,16 +2032,6 @@ export class SDKUI_Localizator {
             default: return "Eliminati";
         }
     }
-    static get DeletionOperationInterrupted() {
-        switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Löschvorgang abgebrochen";
-            case CultureIDs.En_US: return "Deletion operation interrupted";
-            case CultureIDs.Es_ES: return "Operación de eliminación interrumpida";
-            case CultureIDs.Fr_FR: return "Opération de suppression interrompue";
-            case CultureIDs.Pt_PT: return "Operação de exclusão interrompida";
-            default: return "Operazione di eliminazione interrotta";
-        }
-    }
     static get Deny() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ablehnen";
@@ -2559,6 +2579,26 @@ export class SDKUI_Localizator {
             default: return "Download file";
         }
     }
+    static get DownloadInterrupted() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Download abgebrochen";
+            case CultureIDs.En_US: return "Download interrupted";
+            case CultureIDs.Es_ES: return "Descarga interrumpida";
+            case CultureIDs.Fr_FR: return "Téléchargement interrompu";
+            case CultureIDs.Pt_PT: return "Download interrompido";
+            default: return "Download interrotto";
+        }
+    }
+    static get DownloadInterruptedFiles() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Download abgebrochen: {{0}} von {{1}} Dateien heruntergeladen";
+            case CultureIDs.En_US: return "Download interrupted: {{0}} of {{1}} files downloaded";
+            case CultureIDs.Es_ES: return "Descarga interrumpida: {{0}} de {{1}} archivos descargados";
+            case CultureIDs.Fr_FR: return "Téléchargement interrompu : {{0}} fichiers sur {{1}} téléchargés";
+            case CultureIDs.Pt_PT: return "Download interrompido: {{0}} de {{1}} arquivos baixados";
+            default: return "Download interrotto: scaricati {{0}} file su {{1}}";
+        }
+    }
     static get Download_in_Process() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Download läuft";
@@ -2705,16 +2745,6 @@ export class SDKUI_Localizator {
                 return "Il nome esiste già nella cronologia di accesso. Si prega di scegliere un nome diverso";
         }
     }
-    static get DuplicationOperationInterrupted() {
-        switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Duplikationsvorgang abgebrochen";
-            case CultureIDs.En_US: return "Duplication operation interrupted";
-            case CultureIDs.Es_ES: return "Operación de duplicación interrumpida";
-            case CultureIDs.Fr_FR: return "Opération de duplication interrompue";
-            case CultureIDs.Pt_PT: return "Operação de duplicação interrompida";
-            default: return "Operazione di duplicazione interrotta";
-        }
-    }
     static get DuplicateActivity() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Aktivität duplizieren";
@@ -2755,6 +2785,16 @@ export class SDKUI_Localizator {
             default: return "Configurazione Editor";
         }
     }
+    static get Elapsed() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "vergangen";
+            case CultureIDs.En_US: return "elapsed";
+            case CultureIDs.Es_ES: return "transcurridos";
+            case CultureIDs.Fr_FR: return "écoulés";
+            case CultureIDs.Pt_PT: return "decorridos";
+            default: return "trascorsi";
+        }
+    }
     static get ElectronicInvoice() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Elektronische Rechnung";
@@ -3147,6 +3187,16 @@ export class SDKUI_Localizator {
             default: return "Espansione {{0}} di {{1}}...";
         }
     }
+    static get ExpansionProgressIsEstimated() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Während der Erweiterung werden weitere Knoten gefunden: Der Gesamtwert steigt und der Prozentsatz ist ein Richtwert.";
+            case CultureIDs.En_US: return "More nodes are found during the expansion: the total increases and the percentage is approximate.";
+            case CultureIDs.Es_ES: return "Durante la expansión se encuentran más nodos: el total aumenta y el porcentaje es orientativo.";
+            case CultureIDs.Fr_FR: return "D'autres nœuds sont trouvés pendant l'expansion : le total augmente et le pourcentage est indicatif.";
+            case CultureIDs.Pt_PT: return "Durante a expansão são encontrados mais nós: o total aumenta e a percentagem é indicativa.";
+            default: return "Durante l'espansione vengono trovati altri nodi: il totale aumenta e la percentuale è indicativa.";
+        }
+    }
     static get Expected() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Erwartet";
@@ -4248,6 +4298,116 @@ export class SDKUI_Localizator {
             default: return "Griglie";
         }
     }
+    static get HelpOnLineShiftEnterHint() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Enter zum Senden, Umschalt+Enter für eine neue Zeile";
+            case CultureIDs.En_US: return "Press Enter to send, Shift+Enter for a new line";
+            case CultureIDs.Es_ES: return "Pulsa Intro para enviar, Mayús+Intro para una nueva línea";
+            case CultureIDs.Fr_FR: return "Appuyez sur Entrée pour envoyer, Maj+Entrée pour aller à la ligne";
+            case CultureIDs.Pt_PT: return "Prima Enter para enviar, Shift+Enter para uma nova linha";
+            default: return "Premi Invio per inviare, Maiusc+Invio per andare a capo";
+        }
+    }
+    static get HelpOnLineThinking01() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ich denke darüber nach";
+            case CultureIDs.En_US: return "Thinking about it";
+            case CultureIDs.Es_ES: return "Lo estoy pensando";
+            case CultureIDs.Fr_FR: return "J'y réfléchis";
+            case CultureIDs.Pt_PT: return "Estou a pensar nisso";
+            default: return "Ci sto pensando";
+        }
+    }
+    static get HelpOnLineThinking02() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ich durchsuche die Informationen";
+            case CultureIDs.En_US: return "Searching through the information";
+            case CultureIDs.Es_ES: return "Estoy buscando entre la información";
+            case CultureIDs.Fr_FR: return "Je cherche parmi les informations";
+            case CultureIDs.Pt_PT: return "Estou a procurar nas informações";
+            default: return "Sto cercando tra le informazioni";
+        }
+    }
+    static get HelpOnLineThinking03() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ich lese die relevantesten Inhalte";
+            case CultureIDs.En_US: return "Reading the most relevant content";
+            case CultureIDs.Es_ES: return "Estoy leyendo los contenidos más relevantes";
+            case CultureIDs.Fr_FR: return "Je lis les contenus les plus pertinents";
+            case CultureIDs.Pt_PT: return "Estou a ler os conteúdos mais relevantes";
+            default: return "Sto leggendo i contenuti più pertinenti";
+        }
+    }
+    static get HelpOnLineThinking04() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ich verbinde die Punkte";
+            case CultureIDs.En_US: return "Connecting the dots";
+            case CultureIDs.Es_ES: return "Estoy atando cabos";
+            case CultureIDs.Fr_FR: return "Je relie les points";
+            case CultureIDs.Pt_PT: return "Estou a ligar os pontos";
+            default: return "Sto collegando i punti";
+        }
+    }
+    static get HelpOnLineThinking05() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ich überprüfe die Details";
+            case CultureIDs.En_US: return "Checking the details";
+            case CultureIDs.Es_ES: return "Estoy verificando los detalles";
+            case CultureIDs.Fr_FR: return "Je vérifie les détails";
+            case CultureIDs.Pt_PT: return "Estou a verificar os detalhes";
+            default: return "Sto verificando i dettagli";
+        }
+    }
+    static get HelpOnLineThinking06() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ich bringe die Antwort in Ordnung";
+            case CultureIDs.En_US: return "Putting the answer together";
+            case CultureIDs.Es_ES: return "Estoy ordenando la respuesta";
+            case CultureIDs.Fr_FR: return "Je mets de l'ordre dans la réponse";
+            case CultureIDs.Pt_PT: return "Estou a organizar a resposta";
+            default: return "Sto mettendo in ordine la risposta";
+        }
+    }
+    static get HelpOnLineThinking07() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Fast geschafft";
+            case CultureIDs.En_US: return "Almost there";
+            case CultureIDs.Es_ES: return "Ya casi está";
+            case CultureIDs.Fr_FR: return "On y est presque";
+            case CultureIDs.Pt_PT: return "Estamos quase lá";
+            default: return "Ci siamo quasi";
+        }
+    }
+    static get HelpOnLineThinking08() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Noch einen Moment, ich feile noch daran";
+            case CultureIDs.En_US: return "Just a moment more, polishing it up";
+            case CultureIDs.Es_ES: return "Un momento más, estoy puliendo los detalles";
+            case CultureIDs.Fr_FR: return "Encore un instant, je peaufine";
+            case CultureIDs.Pt_PT: return "Só mais um momento, estou a finalizar";
+            default: return "Ancora un momento, sto rifinendo";
+        }
+    }
+    static get HelpOnLineThinking09() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Schwierige Frage, das dauert etwas länger";
+            case CultureIDs.En_US: return "Tough question, this takes a little longer";
+            case CultureIDs.Es_ES: return "Pregunta difícil, necesito un momento más";
+            case CultureIDs.Fr_FR: return "Question difficile, il faut un peu plus de temps";
+            case CultureIDs.Pt_PT: return "Pergunta difícil, preciso de mais um momento";
+            default: return "Domanda impegnativa, ci vuole un attimo in più";
+        }
+    }
+    static get HelpOnLineThinking10() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Letzter Schritt, ich vervollständige die Antwort";
+            case CultureIDs.En_US: return "One last push, completing the answer";
+            case CultureIDs.Es_ES: return "Último esfuerzo, estoy completando la respuesta";
+            case CultureIDs.Fr_FR: return "Dernier effort, je termine la réponse";
+            case CultureIDs.Pt_PT: return "Último esforço, estou a completar a resposta";
+            default: return "Ultimo sforzo, sto completando la risposta";
+        }
+    }
     static get Hide_CompleteName() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Vollständigen Namen ausblenden";
@@ -4608,6 +4768,16 @@ export class SDKUI_Localizator {
             default: return "\"{{0}}\" non è un indirizzo e-mail valido.";
         }
     }
+    static get InvalidFormatValue() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Der eingegebene Wert entspricht nicht dem erforderlichen Format.";
+            case CultureIDs.En_US: return "The value entered does not match the required format.";
+            case CultureIDs.Es_ES: return "El valor introducido no respeta el formato requerido.";
+            case CultureIDs.Fr_FR: return "La valeur saisie ne respecte pas le format requis.";
+            case CultureIDs.Pt_PT: return "O valor introduzido não respeita o formato exigido.";
+            default: return "Il valore inserito non rispetta il formato richiesto.";
+        }
+    }
     static get InvalidTaxCode() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "\"{{0}}\" ist kein gültiger Steuerkennzeichen.";
@@ -4688,6 +4858,26 @@ export class SDKUI_Localizator {
             default: return "Ultimi";
         }
     }
+    static get LatestErrors() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Letzte Fehler";
+            case CultureIDs.En_US: return "Latest errors";
+            case CultureIDs.Es_ES: return "Últimos errores";
+            case CultureIDs.Fr_FR: return "Dernières erreurs";
+            case CultureIDs.Pt_PT: return "Últimos erros";
+            default: return "Ultimi errori";
+        }
+    }
+    static get LatestWarnings() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Letzte Warnungen";
+            case CultureIDs.En_US: return "Latest warnings";
+            case CultureIDs.Es_ES: return "Últimas advertencias";
+            case CultureIDs.Fr_FR: return "Derniers avertissements";
+            case CultureIDs.Pt_PT: return "Últimos avisos";
+            default: return "Ultimi avvisi";
+        }
+    }
     static get LayoutRemoved() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Layout entfernt";
@@ -5229,6 +5419,16 @@ export class SDKUI_Localizator {
             default: return "Documento di soli metadati";
         }
     }
+    static get MetadataPdfCreationFailed() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Erstellung der Metadaten-PDF fehlgeschlagen";
+            case CultureIDs.En_US: return "Metadata PDF creation failed";
+            case CultureIDs.Es_ES: return "Error al crear el PDF de metadatos";
+            case CultureIDs.Fr_FR: return "Échec de la création du PDF des métadonnées";
+            case CultureIDs.Pt_PT: return "Falha na criação do PDF de metadados";
+            default: return "Creazione PDF metadati fallita";
+        }
+    }
     static get MetadataReferenceInsert() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Metadaten-Referenz einfügen";
@@ -5870,14 +6070,14 @@ export class SDKUI_Localizator {
             default: return "Note e avvisi";
         }
     }
-    static get MaximumNumberOfResults() {
+    static get MaximumNumberOfDocuments() {
         switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Maximale Anzahl von Ergebnissen";
-            case CultureIDs.En_US: return "Maximum number of results";
-            case CultureIDs.Es_ES: return "Número máximo de resultados";
-            case CultureIDs.Fr_FR: return "Nombre maximum de résultats";
-            case CultureIDs.Pt_PT: return "Número máximo de resultados";
-            default: return "Numero massimo di risultati";
+            case CultureIDs.De_DE: return "Maximale Anzahl von Dokumenten";
+            case CultureIDs.En_US: return "Maximum number of documents";
+            case CultureIDs.Es_ES: return "Número máximo de documentos";
+            case CultureIDs.Fr_FR: return "Nombre maximum de documents";
+            case CultureIDs.Pt_PT: return "Número máximo de documentos";
+            default: return "Numero massimo di documenti";
         }
     }
     static get OfSystem() {
@@ -6010,14 +6210,24 @@ export class SDKUI_Localizator {
             default: return "Tra i documenti selezionati è presente un solo file PDF o convertibile: per l'unione ne servono almeno {{0}}";
         }
     }
-    static get OperationFilesInterrupted() {
+    static get OperationDcmtsInterrupted() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return `Vorgang unterbrochen. {{0}} Dokumente verarbeitet`;
+            case CultureIDs.En_US: return `Operation interrupted. Processed {{0}} documents`;
+            case CultureIDs.Es_ES: return `Operación interrumpida. Procesados {{0}} documentos`;
+            case CultureIDs.Fr_FR: return `Opération interrompue. {{0}} documents traités`;
+            case CultureIDs.Pt_PT: return `Operação interrompida. Processados {{0}} documentos`;
+            default: return `Operazione interrotta. Elaborati {{0}} documenti`;
+        }
+    }
+    static get OperationItemsInterrupted() {
         switch (this._cultureID) {
-            case CultureIDs.De_DE: return `Vorgang unterbrochen. {{0}} Dateien verarbeitet`;
-            case CultureIDs.En_US: return `Operation interrupted. Processed {{0}} files`;
-            case CultureIDs.Es_ES: return `Operación interrumpida. Procesados {{0}} archivos`;
-            case CultureIDs.Fr_FR: return `Opération interrompue. {{0}} fichiers traités`;
-            case CultureIDs.Pt_PT: return `Operação interrompida. Processados {{0}} arquivos`;
-            default: return `Operazione interrotta. Elaborati {{0}} files`;
+            case CultureIDs.De_DE: return `Vorgang unterbrochen. {{0}} Elemente verarbeitet`;
+            case CultureIDs.En_US: return `Operation interrupted. Processed {{0}} items`;
+            case CultureIDs.Es_ES: return `Operación interrumpida. Procesados {{0}} elementos`;
+            case CultureIDs.Fr_FR: return `Opération interrompue. {{0}} éléments traités`;
+            case CultureIDs.Pt_PT: return `Operação interrompida. Processados {{0}} elementos`;
+            default: return `Operazione interrotta. Elaborati {{0}} elementi`;
         }
     }
     static get OperationNotAllowed() {
@@ -6556,6 +6766,16 @@ export class SDKUI_Localizator {
             default: return "Il file PDF unito è stato salvato nella cartella \"{{0}}\"";
         }
     }
+    static get PerPage() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "pro Seite";
+            case CultureIDs.En_US: return "per page";
+            case CultureIDs.Es_ES: return "por página";
+            case CultureIDs.Fr_FR: return "par page";
+            case CultureIDs.Pt_PT: return "por página";
+            default: return "per pagina";
+        }
+    }
     static get Pending() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Ausstehend";
@@ -6973,6 +7193,26 @@ export class SDKUI_Localizator {
             default: return "Calcolo delle correlazioni interrotto: vengono mostrate solo le correlazioni già calcolate.";
         }
     }
+    static get RelationsCalculationStoppedProgress() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Berechnung unterbrochen: {{0}} von {{1}} Dokumenten verarbeitet.";
+            case CultureIDs.En_US: return "Calculation stopped: {{0}} of {{1}} documents processed.";
+            case CultureIDs.Es_ES: return "Cálculo interrumpido: {{0}} de {{1}} documentos procesados.";
+            case CultureIDs.Fr_FR: return "Calcul interrompu : {{0}} sur {{1}} documents traités.";
+            case CultureIDs.Pt_PT: return "Cálculo interrompido: {{0}} de {{1}} documentos processados.";
+            default: return "Calcolo interrotto: elaborati {{0}} documenti su {{1}}.";
+        }
+    }
+    static get RelationsCalculationStoppedEmpty() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Berechnung unterbrochen: kein Dokument verarbeitet.";
+            case CultureIDs.En_US: return "Calculation stopped: no documents processed.";
+            case CultureIDs.Es_ES: return "Cálculo interrumpido: ningún documento procesado.";
+            case CultureIDs.Fr_FR: return "Calcul interrompu : aucun document traité.";
+            case CultureIDs.Pt_PT: return "Cálculo interrompido: nenhum documento processado.";
+            default: return "Calcolo interrotto: nessun documento elaborato.";
+        }
+    }
     static get RelatedDcmtsNotFound() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Für das ausgewählte Dokument wurden keine zugehörigen Dokumente gefunden.";
@@ -7239,6 +7479,16 @@ export class SDKUI_Localizator {
             default: return "Aggiorna";
         }
     }
+    static get Remaining() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "verbleibend";
+            case CultureIDs.En_US: return "remaining";
+            case CultureIDs.Es_ES: return "restantes";
+            case CultureIDs.Fr_FR: return "restants";
+            case CultureIDs.Pt_PT: return "restantes";
+            default: return "rimanenti";
+        }
+    }
     static get Reminder() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Erinnerung";
@@ -7379,14 +7629,14 @@ export class SDKUI_Localizator {
             default: return "Ripristina Download";
         }
     }
-    static get ResultsPerPage() {
+    static get DocumentsPerPage() {
         switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Ergebnisse pro Seite";
-            case CultureIDs.En_US: return "Results per page";
-            case CultureIDs.Es_ES: return "Resultados por página";
-            case CultureIDs.Fr_FR: return "Résultats par page";
-            case CultureIDs.Pt_PT: return "Resultados por página";
-            default: return "Risultati per pagina";
+            case CultureIDs.De_DE: return "Dokumente pro Seite";
+            case CultureIDs.En_US: return "Documents per page";
+            case CultureIDs.Es_ES: return "Documentos por página";
+            case CultureIDs.Fr_FR: return "Documents par page";
+            case CultureIDs.Pt_PT: return "Documentos por página";
+            default: return "Documenti per pagina";
         }
     }
     static get RetrieveFile() {
@@ -7399,6 +7649,16 @@ export class SDKUI_Localizator {
             default: return "Recupero file";
         }
     }
+    static get RowNumber() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Zeile {{0}}";
+            case CultureIDs.En_US: return "Row {{0}}";
+            case CultureIDs.Es_ES: return "Fila {{0}}";
+            case CultureIDs.Fr_FR: return "Ligne {{0}}";
+            case CultureIDs.Pt_PT: return "Linha {{0}}";
+            default: return "Riga {{0}}";
+        }
+    }
     static get Rows() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Linien";
@@ -8922,16 +9182,6 @@ export class SDKUI_Localizator {
             default: return "Aggiornamento in corso";
         }
     }
-    static get UpdateOperationWasInterrupted() {
-        switch (this._cultureID) {
-            case CultureIDs.De_DE: return "Der Updatevorgang wurde abgebrochen";
-            case CultureIDs.En_US: return "The update operation was interrupted";
-            case CultureIDs.Es_ES: return "La operación de actualización fue interrumpida";
-            case CultureIDs.Fr_FR: return "L'opération de mise à jour a été interrompue";
-            case CultureIDs.Pt_PT: return "A operação de atualização foi interrompida";
-            default: return "L'operazione di aggiornamento è stata interrotta";
-        }
-    }
     static get Updating() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Aktualisieren";

package/lib/helper/ZipManager.d.ts

@@ -19,7 +19,7 @@ export interface ZipCreateOptions {
     encryptionStrength?: 1 | 2 | 3;
     /** Commento globale ZIP */
     comment?: string;
-    /** Callback progresso: (indice, totale, nomeFile) */
+    /** Callback progresso, invocata a voce conclusa: (voci completate, totale, nomeFile appena aggiunto) */
     onProgress?: (index: number, total: number, filename: string) => void;
     /** Callback progresso singolo file: (bytesElaborati, bytesTotali) */
     onEntryProgress?: (progress: number, total: number) => void;

package/lib/helper/ZipManager.js

@@ -50,7 +50,6 @@ export class ZipManager {
                     throw new DOMException("Operazione annullata", "AbortError");
                 }
                 const file = files[i];
-                onProgress?.(i + 1, total, file.filename);
                 const reader = this.createReader(file.data, { BlobReader, TextReader, Uint8ArrayReader });
                 await zipWriter.add(file.filename, reader, {
                     comment: file.comment,
@@ -60,6 +59,8 @@ export class ZipManager {
                     encryptionStrength,
                     onprogress: onEntryProgress ? (progress, total) => onEntryProgress(progress, total) : undefined
                 });
+                // A voce conclusa, non prima: con un solo file la barra partirebbe gia' al 100%.
+                onProgress?.(i + 1, total, file.filename);
             }
             const commentBytes = comment ? new TextEncoder().encode(comment) : undefined;
             return await zipWriter.close(commentBytes);

package/lib/helper/checkinCheckoutManager.js

@@ -1,7 +1,7 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { AccessLevels, CICO_MetadataNames, SDK_Globals, SystemMIDsAsNumber } from "@topconsultnpm/sdk-ts";
 import TMTooltip from "../components/base/TMTooltip";
-import { dcmtsFileCachePreview, Globalization, removeDcmtsFileCache, SDKUI_Globals, SDKUI_Localizator } from "./index";
+import { Globalization, removeDcmtsFileCache, SDKUI_Globals, SDKUI_Localizator } from "./index";
 import { getBaseExtension, getFullFileExtension } from "./TMUtils";
 import { DownloadTypes } from "../ts/types";
 const findCheckOutUserName = (users, checkoutUserId) => {
@@ -69,8 +69,7 @@ export const cicoDownloadFilesCallback = async (sources, checkout, downloadDcmts
                 updateCicoCheckoutStorageItem(newItem, source.type, "addOrUpdate");
             }
             const cacheKey = `${tid}-${did}`;
-            if (dcmtsFileCachePreview.has(cacheKey))
-                removeDcmtsFileCache(cacheKey);
+            removeDcmtsFileCache(cacheKey);
             files.push({ TID: tid, DID: did, FILEEXT: ext, fileName });
         }
     });

package/lib/helper/dcmtsHelper.d.ts

@@ -2,6 +2,8 @@ import { DcmtTypeDescriptor, MetadataDataTypes, MetadataDescriptor, MetadataForm
 import { MetadataValueDescriptorEx } from "../ts";
 /** Metadati utente (esclusi quelli di sistema) del tipo documento, in ordine di visualizzazione */
 export declare const getUserMetadataSorted: (dtd: DcmtTypeDescriptor | undefined) => Array<MetadataDescriptor>;
+/** Metadato visibile all'utente: stessa regola del risultato di ricerca (vedi getQD), serve almeno la visualizzazione o la modifica */
+export declare const canViewMetadata: (md: MetadataDescriptor) => boolean;
 /** Formatta un valore scalare (non lista dati): date e numeri rispettano Format e FormatCulture del metadato */
 export declare const formatScalarValue: (value: any, dataType: MetadataDataTypes | undefined, format: MetadataFormats | undefined, formatCulture: string | undefined) => string;
 /** Check if dcmtType (mTID) has configured Detail or Many-to-Many relations */

package/lib/helper/dcmtsHelper.js

@@ -1,4 +1,4 @@
-import { MetadataDataTypes, RelationCacheService, RelationTypes, SDK_Globals } from "@topconsultnpm/sdk-ts";
+import { AccessLevels, MetadataDataTypes, RelationCacheService, RelationTypes, SDK_Globals } from "@topconsultnpm/sdk-ts";
 import { formatDateTimeByMetadataFormat, formatNumberByMetadataFormat } from "./TMUtils";
 /** Metadati utente (esclusi quelli di sistema) del tipo documento, in ordine di visualizzazione */
 export const getUserMetadataSorted = (dtd) => {
@@ -6,6 +6,8 @@ export const getUserMetadataSorted = (dtd) => {
         .filter(md => md.id !== undefined && md.id > 100 && md.isSystem !== 1)
         .sort((a, b) => (a.ordinalPosition ?? 0) - (b.ordinalPosition ?? 0));
 };
+/** Metadato visibile all'utente: stessa regola del risultato di ricerca (vedi getQD), serve almeno la visualizzazione o la modifica */
+export const canViewMetadata = (md) => !(md.perm?.canView == AccessLevels.No && md.perm?.canUpdate == AccessLevels.No);
 /** Formatta un valore scalare (non lista dati): date e numeri rispettano Format e FormatCulture del metadato */
 export const formatScalarValue = (value, dataType, format, formatCulture) => {
     if (value === undefined || value === null || value === '')

package/lib/hooks/useCheckInOutOperations.d.ts

@@ -20,11 +20,5 @@ export interface UseCheckInOutOperationsReturn {
     copyCheckoutPathToClipboardCallback: (dcmt: DcmtInfo, filename: string) => void;
     handleCheckOutCallback: (dcmt: DcmtInfo, checkout: boolean, filename: string, downloadDcmtsAsync: (params: DownloadDcmtsAsyncParams) => Promise<void>, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
     handleCheckInCallback: (dcmt: DcmtInfo, checkoutDate?: string | null, onRefreshAsync?: (tid: number | undefined, did: number | undefined, refreshUI?: boolean, metadataResult?: SearchResultDescriptor | null) => Promise<void>) => Promise<void>;
-    showCicoWaitPanel: boolean;
-    cicoWaitPanelTitle: string;
-    showCicoPrimaryProgress: boolean;
-    cicoPrimaryProgressText: string;
-    cicoPrimaryProgressValue: number;
-    cicoPrimaryProgressMax: number;
 }
 export declare const useCheckInOutOperations: (props: UseCheckInOutOperationsProps) => UseCheckInOutOperationsReturn;