@esfaenza/extensions 19.2.30 → 20.3.2

package/index.d.ts

@@ -1,5 +1,1048 @@
+import * as i0 from '@angular/core';
+import { PipeTransform, ModuleWithProviders, Injector, Type, InjectionToken } from '@angular/core';
+import * as i2 from '@esfaenza/localizations';
+import { BaseLocalization, LocalizationService } from '@esfaenza/localizations';
+import { ReplaySubject, Subject, Observable } from 'rxjs';
+import { Location } from '@angular/common';
+import { Router } from '@angular/router';
+import { NgForm } from '@angular/forms';
+
+/** Classe di configurazione per il modulo di estensione */
+declare class ExtensionsModuleConfig {
+    /** Indica se i metodi di estensione che utilizzano le date permettono l'uso di date in utc */
+    allow_utc?: boolean;
+    /** Prefisso delle searchView che serve per storicizzarle evitando di tirarsi in memoria anche tutti gli oggetti. Se vuoto viene supposto 'Hot' */
+    appsearch_prefix?: string;
+    /** Attiva la modalità di debug per l'esposizione di messaggi significativi */
+    debugMode?: boolean;
+}
+
 /**
- * Generated bundle index. Do not edit.
+* Service che fornisce dei metodi di estensione per la gestione/manipolazione delle date
+*/
+declare class DateService {
+    private locProvider;
+    private allowUtc;
+    Initialized: ReplaySubject<void>;
+    /**
+     * Oggetto statico di localizzazione per i messaggi di questa Service
+     */
+    private loc;
+    /**
+     * Oggetto di configurazione per tenere da conto le informazioni sui formati
+     */
+    private cfg;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(locProvider: BaseLocalization, allowUtc: boolean);
+    init(): Promise<void>;
+    /**
+     * Aggiusta una data in "istante finale" in base a qual è la parte di data significativa.
+     *
+     * Es. Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
+     *
+     * @param {any} date Data qualsiasi (Date, stringa, dayjs...), verrà ricondotta ad un oggetto dayJs
+     * @param {'day' | 'hour' | 'minute'} timepart Parte significativa della data
+     * @param {boolean} printSeconds Indica se effettuare la stampa dei secondi o no
+     */
+    adjustDateToFinalInstant(date: any, timepart: 'day' | 'hour' | 'minute', printSeconds?: boolean): string;
+    /**
+     * Funzione che effettua l'ordinamento fra 2 date in base alla direzione specificata
+     *
+     * @param {any} a Prima data per il confronto
+     * @param {any} b Seconda data per il confronto
+     * @param {'asc' | 'desc'} direction Direzione rispetto a cui ordinare le due date
+     *
+     * @returns {number} 0 se le date sono uguali, 1 se la data A deve venire logicamente prima della data B, -1 altrimenti
+     */
+    dateSort(a: any, b: any, direction: 'asc' | 'desc'): number;
+    /**
+     * Effettua il trim dei secondi da una data espressa come stringa
+     *
+     * @param {string} value Data espressa come stringa
+     *
+     * @returns {string} Data senza i secondi
+     */
+    trimSeconds(value: string): string;
+    /**
+     * Data una lista di date Da e una lista di date A restituisce un oggetto rappresentante il range che include tutte le date passate
+     *
+     * @param {any[]} fromDates Lista dei Da
+     * @param {any[]} toDates Lista dei A
+     *
+     * @returns {{ from: any, to: any }} Range di date Da - A che include tutti i valori di **fromDates** e **toDates**
+     */
+    getMinMaxDatesRange(fromDates: any[], toDates: any[]): {
+        from: any;
+        to: any;
+    };
+    /**
+     * Ottiene la conversione di una data in qualsiasi formato al formato standard DayJs
+     *
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} useUtc Indica se usare l'estensione utc di Dayjs per parsare la data o no
+     * @param {string} format formato in cui emettere la conversione
+     *
+     * @returns {any} Data in modalità {format}
+     */
+    getDateConvertion(date: any, useUtc?: boolean, format?: 'date' | 'timestring' | 'dayjs', timestringSmall?: boolean): any;
+    private formattedDayjs;
+    /**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse una data vera e propria, **false** altrimenti
+     *
+     * @param {any} check Oggetto da controllare
+     *
+     * @returns {boolean} Indicazione se l'oggetto è un vero Date di Javascript o no
+     */
+    private isJsDate;
+    /**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse un DayJs vero e proprio, **false** altrimenti
+     *
+     * @param {any} check Oggetto da controllare
+     * @returns {boolean} Indicazione se l'oggetto è un vero DayJs o no
+     */
+    private isDayJs;
+    /**
+     * Ottiene la formattazione di una data in base alla versione richiesta "small" o "long" e a se stampare o meno i secondi
+     *
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} small Indica se formattarla con un formato breve (se **true**) o un formato più lungo (se **false**)
+     *
+     * @returns {string} Data formattata nel formato richiesto
+     */
+    getFormatted(date: any, small: boolean, seconds: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateService, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateService>;
+}
+
+/**
+ * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
+ */
+declare class LocDatePipe implements PipeTransform {
+    private dts;
+    /**
+     * @ignore
+     */
+    constructor(dts: DateService);
+    /**
+     * Trasformazione della data in input in base al formato richiesto
+     *
+     * @param {any} value Valore da ricondurre ad una data e formattare
+     * @param {string} format Formato in output della data da visualizzare
+     *
+     * @returns {string} Data formattata in base al formato
+     */
+    transform(value: any, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocDatePipe, "loc_date", false>;
+}
+
+declare class ExtensionsModule {
+    static forRoot(config?: ExtensionsModuleConfig): ModuleWithProviders<ExtensionsModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtensionsModule, [typeof LocDatePipe], [typeof i2.LocalizationModule], [typeof LocDatePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExtensionsModule>;
+}
+
+/**
+ * Classe che rappresenta una risposta ricevuta da un Backend
+ */
+declare class CallResult<T = never> {
+    /** Tempo impiegato perché la chiamata terminasse */
+    elapsedtime: string;
+    /** **true** se tutto è andato bene, **false** altrimenti */
+    success: boolean;
+    /** Indica se ci sono errori */
+    haserror: boolean;
+    /** Codice dell'eventuale errore restituito */
+    errorcode: string;
+    /** Log dell'eventuale errore restituito */
+    error: string;
+    /** ID dell'eventuale entità relativa a questa risposta */
+    entityid: any;
+    /** Indica se ci sono warning */
+    haswarning: boolean;
+    /** Log dell'eventuale warning restituito */
+    warning: string;
+    /** Entità collegata a questo CallResult */
+    entity: T;
+}
+
+/**
+ * Service che fornisce alcuni semplici funzioni di Hashing / GUID / ecc...
+ */
+declare class HashingService {
+    /**
+     * Generazione di un GUID pseudo-univoco
+     *
+     * @returns {string} il GUID generato
+     */
+    getGUID(): string;
+    /**
+     * Calcolo dell'hash su un oggetto
+     *
+     * @param {any} o Oggetto di cui calcolare l'hash
+     * @param {number} level Livello di ricorsione nel caso venga effettuato l'hash di un oggetto che contiene altri oggetti
+     * @param {boolean} navigateFullDepth Indica se navigare l'oggetto per l'intera lunghezza. In caso contrario si ferma al secondo livello
+     *
+     * @returns {string} Hash generato per l'oggetto in questione
+     */
+    hashObject(o: any, level?: number, navigateFullDepth?: boolean, precise?: boolean): string;
+    /**
+     * Hash più semplice e più veloce dell'md5, ma meno sicuro
+     *
+     * Vedi https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
+     *
+     * @param {string} str Stringa di cui calcolare l'hash
+     */
+    private simpleHash;
+    /**
+     * Blacklist dei tipi da ignorare quando si effettua l'hashing degli oggetti
+     */
+    private objBlacklist;
+    /**
+     * Genera una stringa che identifica univocamente l'oggetto in questione
+     *
+     * @param {any} o Oggetto di cui calcolare la stringa univoca
+     * @param {number} level Livello di ricorsione nel caso venga effettuato l'hash di un oggetto che contiene altri oggetti
+     * @param {boolean} navigateFullDepth Indica se navigare l'oggetto per l'intera lunghezza. In caso contrario si ferma al secondo livello
+     */
+    private stringify;
+    /**
+     * Data una stringa restituisce l'md5
+     *
+     * @param {string} s Stringa di cui calcolare l'md5
+     * @returns {string} md5 della stringa **s**
+     */
+    md5(s: string): string;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private md5cycle;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private cmn;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private ff;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private gg;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private hh;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private ii;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private md51;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private md5blk;
+    /**
+     * Array dei possibili valori di un simbolo esadecimale
+     */
+    private hex_chr;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private rhex;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private hex;
+    /**
+     * @ignore
+     *
+     * Metodo di utilità per il calcolo dell'md5
+     */
+    private add32;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HashingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HashingService>;
+}
+
+/**
+ * Service che fornisce funzionalità di alert nei tipi fondamentali: success, info, warning e danger
+ */
+declare class MessageService {
+    private injector;
+    private locProvider;
+    private hash;
+    /** Oggetto statico in supporto alla localizzazione */
+    private loc;
+    /** Template di un warning con richiesta di conferma */
+    private warningSwalWithCancel;
+    /** Template di un warning con richiesta di conferma */
+    private successSwalWithCancel;
+    /** Template di un errore */
+    private errorSwal;
+    /** Template di un messaggio di successo */
+    private successSwal;
+    /** Template di un avviso */
+    private warningSwal;
+    /** Template di un messaggio informativo */
+    private infoSwal;
+    /** Template di un warning per la sessione scaduta */
+    private expiredSessionSwal;
+    /** Getter per il servizio dei toast. ngx-toastr è fatta talmente male che la service dev'essere recuperata in questo modo */
+    private get toastr();
+    /** Supporto all'Embedding */
+    Embedded: boolean;
+    MainWindow: Window;
+    MessageObserver: Subject<{
+        event: any;
+        data: any;
+    }>;
+    isBrowser: boolean;
+    /** Costruttore  @ignore */
+    constructor(injector: Injector, locProvider: BaseLocalization, hash: HashingService, platformId: Object);
+    browserCheck(): boolean;
+    configureEmbeddability(mainWindow: Window, messageObserver: Subject<{
+        event: any;
+        data: any;
+    }>): void;
+    init(): Promise<void>;
+    /**
+     * Presentazione di un semplice messaggio di successo
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleSuccess(text: string, secondaryNotificationType?: "toastr" | "swal" | null, secondaryNotificationTimeout?: number): void;
+    /**
+     * Presentazione di un semplice messaggio di informazione
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleInfo(text: string, secondaryNotificationType?: "toastr" | "swal" | null, secondaryNotificationTimeout?: number): void;
+    /**
+     * Presentazione di un semplice messaggio di errore
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleError(text: string, secondaryNotificationType?: "toastr" | "swal" | null, secondaryNotificationTimeout?: number): void;
+    /**
+     * Presentazione di un semplice messaggio di avviso
+     *
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     */
+    simpleWarning(text: string, secondaryNotificationType?: "toastr" | "swal" | null, secondaryNotificationTimeout?: number): void;
+    /**
+     * Ripulisce tutti i messaggi presenti in un dato momento sullo schermo
+     */
+    clearMessages(): void;
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     *
+     * @returns {Promise} Restituisce una Promise col risultato scelto dall'utente (conferma o no)
+     */
+    promiseWarningWithChoice(title: string, text: string): Promise<any>;
+    /**
+     * In base alla configurazione attuale e all'eventuale override per la chiamata del caso indica se bisogna utilizzare toastr o sweetalert
+     *
+     * @param {"toastr" | "swal" | null} providerOverride Override alla modalità configurata
+     *
+     * @returns {"toastr" | "swal"} Indicazione su che provider di messaggi di avviso debba essere utilizzato
+     */
+    private toastrOrSwal;
+    private GuidRepsonseFunctionsMap;
+    simpleWarningWithChoice(title: string, text: string, onsuccess?: Function, onerror?: Function, confirmtext?: string, aborttext?: string): void;
+    simpleSuccessWithChoice(title: string, text: string, onsuccess?: Function, onerror?: Function, confirmtext?: string, aborttext?: string): void;
+    private withChoiceBase;
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onsuccess Callback da chimare su conferma
+     * @param {Function} onerror Callback da chimare su errori
+     */
+    private _simpleWarningWithChoice;
+    /**
+     * Mostra un messaggio di success con richiesta di conferma e gestisce il risultato chiamato i callback **onconfirm** o **onabort**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onconfirm Callback da chimare su conferma
+     * @param {Function} onabort Callback da chimare su annullamento
+     * @param {string} confirmtext Testo del pulsante di azione
+     * @param {string} aborttext Testo del pulsante di annullamento
+     */
+    private _simpleSuccessWithChoice;
+    /**
+     * Metodo base per richiedere una scelta all'utente
+     *
+     * @param {any} swal Swal mixin da utilizzare per visualizzare il messaggio di choice
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onconfirm Callback da chimare su conferma
+     * @param {Function} onabort Callback da chimare su annullamento
+     * @param {string} confirmtext Testo del pulsante di azione
+     * @param {string} aborttext Testo del pulsante di annullamento
+     */
+    private _simpleWithChoice;
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     */
+    observableSimpleWarningWithChoice(title: string, text: string): Observable<boolean>;
+    /**
+     * Mostra un messaggio di avviso che la sessione corrente è scaduta e propone all'utente di navigare al login. Qualora l'utente decidesse di farlo
+     * verrà chiamata la funzione di callback **onnavigate
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onnavigate Callback da chimare su navigazione in corso
+     */
+    expiredSessionMessage(title: string, text: string, onnavigate?: Function): void;
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **CallResult**
+     *
+     * @param {CallResult} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageCallResultResponse(response: CallResult, successMsg: string, errorMsg: string, postSuccess?: Function, postFailure?: Function): void;
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **string**, considerando che:
+     *
+     * Stringa vuota --> Tutto bene
+     *
+     * Stringa piena --> Questo è il messaggio d'errore per cui la chiamata è fallita
+     *
+     * @param {string} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageStringResponse(response: string, successMsg: string, errorMsg: string, postSuccess?: Function, postFailure?: Function): void;
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **boolean**
+     *
+     * @param {string} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageStringResponseBool(response: boolean, successMsg: string, errorMsg: string, postSuccess?: Function, postFailure?: Function): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, [null, { optional: true; }, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}
+
+declare class AppEmbeddingExtensions {
+    private msgService;
+    private router;
+    private location;
+    sidebarWidth: number;
+    EmbeddingSource: ReplaySubject<string>;
+    Embedded: boolean;
+    EmbeddingLevel: number;
+    MainWindow: any;
+    MessageObserver: Subject<{
+        event: any;
+        data: any;
+    }>;
+    private _reloadAllowed;
+    EmbeddedModule: string;
+    private pushedHistories;
+    private isBrowser;
+    constructor(msgService: MessageService, router: Router, location: Location, platformId: Object);
+    private waitForMyConfigAndForceEmbeddedModule;
+    IsReloadAllowed(): boolean;
+    private MessageBarrierDebouncMs;
+    private OnMessageCallBarrier;
+    private messageHash;
+    configureEmbeddability(): void;
+    private onNavigateBack;
+    replaceState(basePath: string, url: string): void;
+    refreshBoundariesOnMenuCollapse(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEmbeddingExtensions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppEmbeddingExtensions>;
+}
+
+/**
+ * WIP: per razionalizzare il fill della routesmap (vedi CRM app.extensions.ts)
+ */
+declare class BaseExtensionsService {
+    private emb;
+    RedirectMap: {
+        [index: string]: {
+            url: string;
+            params: string[];
+        };
+    };
+    RoutesMap: {
+        [index: string]: {
+            route: (param: string) => any;
+        };
+    };
+    constructor(emb: AppEmbeddingExtensions);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseExtensionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseExtensionsService>;
+}
+
+/**
+ * Mappatura del TypeCode del C#
+ */
+declare enum TypeCode {
+    /** @ignore */ Empty = 0,
+    /** @ignore */ Obj = 1,
+    /** @ignore */ DBNull = 2,
+    /** @ignore */ Boolean = 3,
+    /** @ignore */ Char = 4,
+    /** @ignore */ SByte = 5,
+    /** @ignore */ Byte = 6,
+    /** @ignore */ Int16 = 7,
+    /** @ignore */ UInt16 = 8,
+    /** @ignore */ Int32 = 9,
+    /** @ignore */ UInt32 = 10,
+    /** @ignore */ Int64 = 11,
+    /** @ignore */ UInt64 = 12,
+    /** @ignore */ Single = 13,
+    /** @ignore */ Double = 14,
+    /** @ignore */ Decimal = 15,
+    /** @ignore */ DateTime = 16,
+    /** @ignore */ String = 18
+}
+
+/**
+ * Service che fornisce metodi di pubblica utilità
+ */
+declare class UtilityService {
+    /**
+     * Deseleziona il testo eventualmente selezionato
+     */
+    clearTextSelection(): void;
+    /**
+     * Partendo da una lista, dato il nome della proprietà chiave e il valore della chiave selezionata,
+     * trova e restituisce l'oggetto desiderato
+     *
+     * @param {T[]} sourceList Lista di oggetti dentro cui cercare
+     * @param {string} sourceItemIdField Nome della proprietà che rappresenta la chiave di un oggetto di tipo T
+     * @param {string} selectedValue Valore di chiave selezionato
+     *
+     * @returns {T} Oggetto la cui proprietà **sourceItemIdField** assume il valore **selectedValue**
+     */
+    getSelectedItem<T>(sourceList: T[], sourceItemIdField: string, selectedValue: string): T;
+    /**
+     * Effettua il reset di un Form di Angular
+     *
+     * @param {NgForm} form Form da resettare
+     * @param {string} exception1 Campo da non resettare
+     * @param {string} exception2 Campo da non resettare
+     */
+    cleanForm(form: NgForm, exception1?: string, exception2?: string): void;
+    /**
+     * Helper che permette di scaricare un file dato un URL (Generato da una chiamata ad **window.URL.createObjectURL**)
+     *
+     * @param {string} url ObjectURL che rappresenta il file da scaricare
+     * @param {string} filename Nome del file suggerito in fase di salvataggio
+     */
+    fileDownload(url: string, fileName: string): void;
+    /**
+     * Helper per la formattazione di un numero di millisecondi in una stringa più comprensibile per un umano
+     *
+     * @param {number} duration Tempo espresso in millisecondi
+     *
+     * @returns {string} Durata formattata
+     */
+    msToTime(duration: number): string;
+    /**
+     * Helper che permette di scaricare un file in Base64
+     *
+     * @param {string} base64Data Base64 che rappresenta il file da scaricare
+     * @param {string} filename Nome del file suggerito in fase di salvataggio
+     */
+    saveFile(base64Data: string, filename: string): void;
+    /**
+     * Trasforma un Base64 in un ArrayBuffer
+     *
+     * @param {string} base64Data Base64 da trasformare
+     *
+     * @returns {Uint8Array} Array UTF8
+     */
+    private base64ToArrayBuffer;
+    /**
+     * Helper che permette di scaricare un file dato un array di Byte (**Uint8Array**)
+     *
+     * @param {Uint8Array} byte Rappresentazione del file da scaricare
+     * @param {string} filename Nome del file suggerito in fase di salvataggio
+     */
+    private saveByteArray;
+    /**
+     * Utility per lo swap di due elementi di un array
+     *
+     * @param {any[]} array Array di cui invertire due elementi
+     * @param {number} x Indice del primo elemento
+     * @param {number} y Indice del secondo elemento
+     */
+    swap(array: any[], x: number, y: number): void;
+    /**
+     * Helper di trascodifica da tipo c# a tipo Typescript
+     *
+     * @param {TypeCode} type Tipo da trascodificare
+     *
+     * @returns {"boolean" | "number" | "string" | "date"} Tipo Typescript corrispondente
+     */
+    getJsTypeFromTypeCode(type: TypeCode): "boolean" | "number" | "string" | "date";
+    /**
+     * Effettua la clonazione profonda di un oggetto in maniera molto più performante che JSON.parse(JSON.stringify()).
+     *
+     * Usare solo per oggetti puri e quantomeno semplici per evitare complicazioni derivanti dalle semplificazioni che questo metodo assume
+     *
+     * @param {any} source Oggetto da clonare
+     *
+     * @return {any} Clone dell'oggetto passato
+     */
+    deepClone(source: any, type?: Type<any>): any;
+    /**
+     * @ignore
+     * Step ricorsivo per la clonatura degli oggetti. Vedere **deepClone**
+     */
+    private recursiveStep;
+    cast(object: any, clss: Type<any>): any;
+    /** @ignore */
+    private executionTimers;
+    /** @ignore */
+    throttla(id: string, func: Function, throttleTime: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilityService>;
+}
+
+/**
+ * Header per il file CSV che sta venendo generato
+ */
+declare class CsvHeaders {
+    /**
+     * Intestazione della colonna
+     */
+    label: string;
+    /**
+     * Nome della proprietà visualizzata in questa colonna
+     */
+    key: string;
+    /**
+     * Ordine della colonna
+     */
+    order: number;
+    /**
+     * Nome della chiave della proprietà lato es-table
+     */
+    propKey: string;
+    /**
+     * Tipo della colonna (per eventuali formattazioni se si scarica in Excel)
+     */
+    type: 'string' | 'number' | 'date';
+}
+
+/**
+ * Rappresentazione di un oggetto generico
+ */
+declare class GenericItem {
+    /**
+     * Dizionario Chiave - Valore delle proprietà di questo oggetto generico
+     */
+    properties: Record<string, string>;
+}
+
+/**
+ * Decoratore che fornisce la classe di localizzazione per tutte le proprietà esportate con @Export e qualsiasi altro tag che richieda localizzazioni.
+ *
+ * Sostanzilamente aggiunge la proprietà **__loc__** all'oggetto creato dalla classe corrente assegnandogli come valore il tipo del LocalizationService da usare per la traduzione
+ *
+ * @param {Type<LocalizationService>} loc Tipo ereditato dal LocalizationService che può essere creato a runtime sotto contesto della DI di Angular
+ */
+declare function ExportLocalization(loc: Type<LocalizationService>): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => {
+    new (...args: any[]): {
+        __loc__: Type<LocalizationService>;
+    };
+} & T;
+/**
+ * Decoratore di esportazione utilizzabile su una proprietà singola.
+ * Verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
+ *
+ * Ad esempio, da questa configurazione:
+ *
+ * @example
+ * ```
+ * @Export(true, "MyHeader")
+ * ciao: string;
+ * ```
+ *
+ * Nasceranno le seguenti proprietà nell'oggetto esportabile:
+ *
+ * @example
+ * ```
+ * ciao_csvvis: string; => true
+ * ciao: string;
+ * ciao_csvhdr: string => "MyHeader"
+ * ```
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} header Titolo della colonna nel file CSV esportato
+ * @param {string} format Formato di esportazione. Può essere un formato data per i campi data o 'F' per i campi floating point
+ */
+declare const Export: (order: number, header: string, format?: string, tableid?: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Decoratore di esportazione utilizzabile su un oggetto.
+ * Per ogni proprietà dell'oggetto verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
+ * Per essere esportate, le proprietà dell'oggetto devono essere marcate con i Decoratori di esportazione
+ *
+ * Ad esempio, da questa configurazione:
+ *
+ * @example
+ * ```
+ * MyObj {
+ *     @Export(true, "MyHeader")
+ *     ciao: string;
+ * }
+ *
+ * @ExportObject(true, "MyHeader")
+ * test: MyObj;
+ * ```
+ *
+ * Nasceranno le seguenti proprietà nell'oggetto esportabile:
+ *
+ * @example
+ * ```
+ * testciao: string; => Valore di MyObj.ciao
+ * testciao_csvvis: string; => true
+ * testciao_csvhdr: string => "MyHeader"
+ * ```
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {any} type Tipo da esportare
+ */
+declare const ExportAs: (order: number, type: any, prefix?: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Decoratore di esportazione utilizzabile su una lista,
+ * si utilizzano 2 navigator rispettivamente per la valorizzazione dell'Header e del Valore e
+ * per ogni elemento dell'array verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr)
+ *
+ * ATTENZIONE: Gli oggetti esportati in questa modalità non devono presentare altri tag di tipo @Export{...} all'interno. Fa tutto questo decoratore
+ *
+ * I navigator hanno questa convenzione:
+ *
+ * . --> divide due proprietà da richiamare consecutivamente: "a.b" richiamerà "obj.a.b";
+ *
+ * | --> divide più proprietà per le concatenazioni con uno spazio fra una e l'altra: "regdesc|slice.slicename" diventerà obj.regdesc + " " + obj.slice.slicename
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna
+ * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna
+ * @param {string} valueformat Formato di esportazione per i valori selezionati dal **valuenavigator**. Può essere un formato data per i campi data o 'F' per i campi floating point
+ */
+declare const ExportList: (order: number, headernavigator: string, valuenavigator: string, valueformat?: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Decoratore di esportazione utilizzabile su un dizionario. Se ad esempio si vogliono generare le colonne
+ *
+ * Valore A = 1
+ *
+ * Valore B = 2
+ *
+ * Valore C = 3
+ *
+ * partendo da un oggetto iniziale { Valore { A: 1, B: 2, C: 3 } }
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} headerprefix Prefisso per l'header
+ * @param {string} valueprefix Prefisso per il valore
+ */
+declare const ExportDictionary: (order: number, headerprefix: string, valueprefix: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Service che si occupa dell'esportazione degli oggetti marcati dai Decoratori **ExportDictionary**, **ExportList**, **ExportAs** o **Export**
+ */
+declare class ExportService {
+    private dates;
+    private utiExts;
+    private lc;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(dates: DateService, utiExts: UtilityService, lc: LocalizationService);
+    /**
+     * Data una lista di oggetti genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * @param {any[]} objs Oggetti da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    setupForExport(objs: any[], columns?: string[]): CsvHeaders[];
+    /**
+     * Data una lista di oggetti generici genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * @param {GenericItem[]} objs Oggetti generici da esportare
+     * @param {CsvHeaders[]} columns Colonne richieste dall'esportazione
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    setupForGenericExport(objs: GenericItem[], columns: CsvHeaders[]): CsvHeaders[];
+    /**
+     * Dato un oggetto generico genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * Metodo interno richiamato da **setupForGenericExport**
+     *
+     * @param {GenericItem} obj Oggetto generico da esportare
+     * @param {CsvColumn[]} columns Colonne richieste dall'esportazione
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    private parseAndGetGenericHeaders;
+    /**
+     * Dato un oggetto genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * Metodo interno richiamato da **setupForExport**
+     *
+     * @param {any} obj Oggetto generico da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    private parseAndGetHeaders;
+    /**
+     * Setup per l'esportazione di una singola proprietà.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    private parseProperty;
+    /**
+     * Setup per l'esportazione di una singola proprietà da un oggetto.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no.
+     *
+     * Per ottenere il valore e l'header della proprietà vengono utilizzati i navigatori auto-generati nel decoratore **ExportAs**
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    private parseObject;
+    /**
+     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
+     *
+     * => Recupero il valore utilizzando i navigatori
+     *
+     * => Recupero l'header utilizzando i navigatori
+     *
+     * => Con il valore ci creo la property
+     *
+     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    private parseList;
+    /**
+     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
+     *
+     * => Recupero il valore utilizzando i navigatori
+     *
+     * => Recupero l'header utilizzando i navigatori
+     *
+     * => Con il valore ci creo la property
+     *
+     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     */
+    private parseDictionary;
+    /**
+     * Effettua l'esportazione in file CSV
+     */
+    private exportCSV;
+    private exportCSVBuffer;
+    /** Effettua l'esportazione del file Excel basandosi sul modulo **ExcelJS**, sugli header **headers** e sui dati **data** */
+    private exportExcel;
+    private exportExcelBuffer;
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    export(items: any[], format: 'CSV' | 'XLSX', fileName: string, type: Type<any>, columnsFilter?: string[], genericHeaders?: CsvHeaders[]): CsvHeaders[];
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    exportBuffer(items: any[], format: 'CSV' | 'XLSX', fileName: string, type: Type<any>, columnsFilter?: string[], genericHeaders?: CsvHeaders[]): Uint8Array;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportService>;
+}
+
+/**
+ * Service che fornisce un accesso base in lettura/scrittura sulla clipboard
+ */
+declare class ClipboardService {
+    private msgService;
+    private locProvider;
+    /**
+     * Oggetto statico di localizzazione per i messaggi di questa Service
+     */
+    private loc;
+    private isBrowser;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(msgService: MessageService, locProvider: BaseLocalization, platformId: Object);
+    /**
+     * Prende il valore della clipboard.
+     * Si può specificare se ci si aspetta una lista o una matrice di valori in modo da ricevere già un risultato utilizzabile
+     *
+     * @param {'array' | 'matrix'} style Stile dell'output desiderato, se array o matrice
+     * @param {Function} valueFoundCallback Callback che questa funzione chiamerà una volta ottenuto i valori richiesti dalla clipboard
+     */
+    getClipboard(style: 'array' | 'matrix', valueFoundCallback: (values: string[] | string[][]) => void): Promise<void>;
+    /** @ignore */
+    private doClipboardDataGet;
+    /**
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline)
+     *
+     * @param {string} data contenuto letto dalla clipboard
+     *
+     * @returns {string[]} Array contenente il testo preso dalla clipboard diviso per riga
+     */
+    private getClipboardLines;
+    /**
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline) e colonne (separate da tab)
+     *
+     * @param {string} data contenuto letto dalla clipboard
+     *
+     * @returns {string[][]} Matrice contenente il testo preso dalla clipboard diviso per riga e colonna
+     */
+    private getClipboardMatrix;
+    /**
+     * Metodo che copia un testo all'interno della clipboard
+     *
+     * @param {string} text Testo da inserire nella clipboard
+     */
+    copyTextToClipboard(text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, [null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}
+
+/**
+ * Token che indica il prefisso delle searchView che serve per storicizzarle evitando di tirarsi in memoria anche tutti gli oggetti. Se vuoto viene supposto 'Hot'
+ */
+declare const APPSEARCH_PREFIX: InjectionToken<string>;
+/**
+ * Token che indica se i metodi di estensione che utilizzano le date permettono l'uso di date in utc
  */
-/// <amd-module name="@esfaenza/extensions" />
-export * from './public-api';
+declare const EXT_ALLOW_UTC: InjectionToken<boolean>;
+/** Modalità di Debug */
+declare const EXT_DEBUG_MODE: InjectionToken<boolean>;
+
+/** Enumeratore dei tipi di messaggio che i moduli esterni possono contattare sull'applicazione principale */
+declare enum InboundMessageTypes {
+    /** Evento di navigazione */
+    Navigation = 0
+}
+
+/** Classe che rappresenta un generico messaggio scambiato fra applicazione e moduli */
+declare class InterComMessage {
+    type: any;
+    message: any;
+    /**
+     * Costruttore
+     *
+     * @param type Tipo di messaggio
+     * @param message Contenuto del messaggio
+     */
+    constructor(type: any, message: any);
+}
+
+/** Service che si occupa di gestire la comunicazione fra i moduli interni ed esterni dell'applicativo */
+declare class InterComService {
+    /** Messaggi in uscita, uno per ogni recipient registratosi dall'entrypoint **register** */
+    outbounds: {
+        [id: string]: Subject<InterComMessage>;
+    };
+    /** Messaggi in entrata, unico per applicazione principale */
+    inbounds: Subject<InterComMessage>;
+    /**
+     * Metodo che permette di inviare un messaggio dall'applicazione ad un modulo esterno o viceversa
+     *
+     * @param {any} messageType Tipologia di messaggio. Sarà di tipo **InboundMessageTypes** per tutti i messaggi inbound, dinamico per tutti i mesaggi outbound (il tipo dipenderà dagli enum dei messaggi dei moduli esterni)
+     * @param {any} message Messaggio da inviare che può essere un dto in casi complessi ma dovrà essere gestito a dovere lato implementativo
+     * @param {string} recipient Destinatario del messaggio. Per i messaggi inbound dev'essere lasciato vuoto, per i messaggi outbound sarà valorizzato alla chiave del modulo a cui si vuole inviare il messaggio
+     */
+    send(messageType: any, message: any, recipient?: string): void;
+    /**
+     * Permette di registrare un modulo esterno alla lista dei moduli in listening sulla coda di messaggi
+     *
+     * @param {string} key Chiave del modulo da registrare. Tutti i messaggi inbound saranno inviati dall'applicazione principale su questa chiave
+     */
+    register(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterComService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InterComService>;
+}
+
+export { APPSEARCH_PREFIX, AppEmbeddingExtensions, BaseExtensionsService, CallResult, ClipboardService, CsvHeaders, DateService, EXT_ALLOW_UTC, EXT_DEBUG_MODE, Export, ExportAs, ExportDictionary, ExportList, ExportLocalization, ExportService, ExtensionsModule, GenericItem, HashingService, InboundMessageTypes, InterComMessage, InterComService, LocDatePipe, MessageService, UtilityService };