@esfaenza/es-table 19.2.47 → 20.3.0

package/index.d.ts

@@ -1,5 +1,2583 @@
+import * as _angular_core from '@angular/core';
+import { ChangeDetectorRef, EventEmitter, WritableSignal, Signal, TemplateRef, ElementRef, QueryList, NgZone, Renderer2, Type, PipeTransform, ModuleWithProviders, InjectionToken } from '@angular/core';
+import * as i18 from '@esfaenza/localizations';
+import { LocalizationService } from '@esfaenza/localizations';
+import { MessageService, ExportService, UtilityService, DateService, HashingService, ClipboardService, AppEmbeddingExtensions } from '@esfaenza/extensions';
+import * as i16 from '@angular/forms';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { PreferencesService } from '@esfaenza/preferences';
+import * as i21 from '@esfaenza/ngx-contextmenu';
+import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
+import { SafeHtml } from '@angular/platform-browser';
+import { ReplaySubject, Subject } from 'rxjs';
+import * as i22 from '@angular/cdk/drag-drop';
+import { CdkDragDrop, CdkDrag } from '@angular/cdk/drag-drop';
+import * as i19 from 'ngx-bootstrap/modal';
+import { ModalDirective } from 'ngx-bootstrap/modal';
+import * as i15 from '@angular/common';
+import * as i17 from '@angular/router';
+import * as i20 from 'ngx-bootstrap/dropdown';
+import * as i23 from '@esfaenza/forms-and-validations';
+import * as i24 from 'primeng/tooltip';
+import * as i25 from '@esfaenza/access-control';
+import * as i26 from 'primeng/select';
+
+/** Componente che si occupa della paginazione di una tabella */
+declare class EsTablePagerComponent {
+    private msgExts;
+    lc: LocalizationService;
+    cdr: ChangeDetectorRef;
+    /** Dimensione di pagina attuale */
+    CurrentPageSize: _angular_core.InputSignal<number>;
+    /** View gestita, che può essere un IAppSearch o una ReportView */
+    View: _angular_core.InputSignal<any>;
+    /** Indica se deve mostrare un warning quando si cercano di solezionare come elementi da visualizzare "Tutti" */
+    WarnOnAll: _angular_core.InputSignal<boolean>;
+    /** Indica se dare la possibilità o meno di selezionare "Tutti" nelle opzioni di paginazione */
+    AllSearch: _angular_core.InputSignal<boolean>;
+    /** Placeholder che identifica il "Tutti" */
+    DefaultAll: _angular_core.InputSignal<number>;
+    /** Indica se attivare la modalità gruppo con stili più snelli per apparire sotto ai raggruppamenti */
+    GroupMode: _angular_core.InputSignal<boolean>;
+    /** Indica se utilizzare il conteggio dei gruppi o degli oggetti */
+    GroupCount: _angular_core.InputSignal<boolean>;
+    /** Indica il testo che va a sostituire "Oggetti Visualizzati" in caso si stia facendo qualcosa di custom, Ignorato in caso di gruppi */
+    CountLabel: _angular_core.InputSignal<string>;
+    /** Indica se visualizzare il numero totale di oggeti presenti */
+    ShowCount: _angular_core.InputSignal<boolean>;
+    /** Indica se visualizzare il numero totale di oggeti presenti */
+    ShowPaging: _angular_core.InputSignal<boolean>;
+    /** Indica il numero totale di oggeti presenti */
+    PagerCount: _angular_core.InputSignal<number>;
+    /** Indica se mostrare o meno il contenuto @deprecated usata solo da MatrixValuesComponent nella lib relativa */
+    Hidden: _angular_core.InputSignal<boolean>;
+    /** Output invocato quando il numero di elementi per pagina viene modificato da un click utente */
+    pagingSelected: EventEmitter<number>;
+    /** @ignore */
+    constructor(msgExts: MessageService, lc: LocalizationService, cdr: ChangeDetectorRef);
+    /** Modello su cui la select effettua operazioni di selezione */
+    Model: WritableSignal<number>;
+    /** Opzioni di paginazione */
+    private _pagingOptions;
+    PagingOptionsForSelect: Signal<{
+        id: number;
+        description: string;
+    }[]>;
+    /**
+     * Funzione richiamata dal template quando un utente clicca su un numero di paginazione.
+     *
+     * Cliccare 2 volte sullo stesso numero causa comunque un refresh dei dati
+     *
+     * @param {number} pageSize Dimensione selezionata lato UI
+     */
+    choice(pageSize: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTablePagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EsTablePagerComponent, "es-paging", never, { "CurrentPageSize": { "alias": "CurrentPageSize"; "required": false; "isSignal": true; }; "View": { "alias": "View"; "required": false; "isSignal": true; }; "WarnOnAll": { "alias": "WarnOnAll"; "required": false; "isSignal": true; }; "AllSearch": { "alias": "AllSearch"; "required": false; "isSignal": true; }; "DefaultAll": { "alias": "DefaultAll"; "required": false; "isSignal": true; }; "GroupMode": { "alias": "GroupMode"; "required": false; "isSignal": true; }; "GroupCount": { "alias": "GroupCount"; "required": false; "isSignal": true; }; "CountLabel": { "alias": "CountLabel"; "required": false; "isSignal": true; }; "ShowCount": { "alias": "ShowCount"; "required": false; "isSignal": true; }; "ShowPaging": { "alias": "ShowPaging"; "required": false; "isSignal": true; }; "PagerCount": { "alias": "PagerCount"; "required": false; "isSignal": true; }; "Hidden": { "alias": "Hidden"; "required": false; "isSignal": true; }; }, { "pagingSelected": "pagingSelected"; }, never, never, false, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Classe che identifica un ordinamento di una colonna
  */
-/// <amd-module name="@esfaenza/es-table" />
-export * from './public-api';
+declare class AppOrdering {
+    id: string;
+    order?: 'DESC' | 'ASC';
+    /**
+     * Costruttore
+     *
+     * @param {string} id ID della colonna a cui si vogliono applicare ordinamenti, deve combaciare all'id messo nella dichiarazione dell'ES-TD/TH
+     * @param {'DESC' | 'ASC' } order Ordinamento da applicare alla colonna, Discendente/Ascendente, default 'null' per indicare assenza di ordine
+     */
+    constructor(id: string, order?: 'DESC' | 'ASC');
+}
+
+/** Classe che rappresenta un'aggregazione */
+declare class GroupAggregation {
+    column: string;
+    aggregation: 'min' | 'max' | 'sum';
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna aggregata
+     * @param {'min' | 'max' | 'sum' } aggregation Aggregazione da effettuare su questa colonna
+     * @param {string} value Valore dell'aggregazione
+     */
+    constructor(column: string, aggregation: 'min' | 'max' | 'sum', value: string);
+}
+
+/** Classe che rappresenta un Gruppo con le proprie aggregazioni */
+declare class Group {
+    column: string;
+    count: number;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna raggruppata
+     * @param {number} count Numero di elementi raggruppati sotto questa colonna
+     * @param {string} value Valore del Gruppo
+     */
+    constructor(column: string, count: number, value: string);
+    /** Aggregazioni presenti su questo gruppo, valide per tutte le altre colonne (non a loro volta gruppate) */
+    aggregations: GroupAggregation[];
+}
+
+/** Identifica una selezione applicabile agli oggetti presentati in una tabella */
+declare class ItemsSelection<T> {
+    /**
+     * Costruttore
+     *
+     * @param {T[]} selected Oggetti da considerare selezionati
+     */
+    constructor(selected: T[]);
+    /** Conteggio degli oggetti selezionati */
+    count: number;
+    /** Se **all** è **false** indica gli elementi da includere, altrimenti è insensato */
+    items: T[];
+    /** Se **all** è **false** indica i gruppi, altrimenti è insensato */
+    groups: Group[];
+    /** Indica se tutti gli elementi sono da considerarsi selezionati (anche quelli di altre pagine) */
+    all: boolean;
+    /** Se **all** è **true**, indica gli elementi da escludere, altrimenti è insensato */
+    exclusions: T[];
+    /** Se **all** è **true**, indica i gruppi da escludere, altrimenti è insensato */
+    group_exclusions: Group[];
+}
+
+/** Classe che rappresenta un filtro su un gruppo */
+declare class GroupFilter {
+    column: string;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna gruppata per cui si richiede di filtrare
+     * @param {string} value Valore del gruppo su questa **column** per cui si richiede di filtrare
+     */
+    constructor(column: string, value: string);
+}
+
+/** Classe che rappresenta o un gruppo o una aggregazione su una colonna. Usata solo internamente */
+declare class GroupOrAggregation {
+    column: string;
+    aggregation?: 'min' | 'max' | 'sum';
+    datatype?: 'string' | 'date' | 'number';
+    /**
+     * Costruttore
+     *
+     * @param {string} column Colonna su cui è presente o un gruppo o un'aggregazione
+     * @param {'min' | 'max' | 'sum' } aggregation Aggregazione presente sulla **column**. Se questo campo è nullo significa che è un gruppo.
+     * @param {'string' | 'date' | 'number'} datatype Tipo di dati contenuto nella colonna **column** se non c'è alcuna aggregazione è inutile, pertanto non sarà valorizzato
+     */
+    constructor(column: string, aggregation?: 'min' | 'max' | 'sum', datatype?: 'string' | 'date' | 'number');
+}
+
+/** Classe che identifica un parametro generico per un report */
+declare class ReportParam {
+    /** Codice del parametro */
+    id: string;
+    /** Descrizione del parametro */
+    description: string;
+    /** Sequenza del parametro per ordinarlo logicamente rispetto agli altri */
+    seq: number;
+    /** Typecode C# della tipologia di parametro */
+    typecode: number;
+    /** Indica se i parametro è richiesto o meno */
+    required: boolean;
+    /** Valore del parametro, offerto sia come valore di default o in alternativa riempito lato UI */
+    value?: any;
+    /** Indica se questo parametro si basa su un enum. Se questa proprietà è true mi aspetto che almeno **enumtype** sia valorizzato */
+    isenum: boolean;
+    /** Indica se questo parametro si basa su un dizionario. Se questa proprietà è true mi aspetto che almeno **dictype** sia valorizzato */
+    isdictionary: boolean;
+    /** Indica se il parametro è di tipo data */
+    isdate: boolean;
+    /** Indica se il parametro è di tipo boolean */
+    isboolean: boolean;
+    /** Valori disponibili per questo parametro, da valorizzare in caso **enumtype** o **dictype** fossero valorizzati */
+    availablevalues?: {
+        id: string;
+        description: string;
+    }[];
+    /** Tipo enumerabile del parametro (qualora fosse un dizionario di valori) */
+    enumtype?: string;
+    /** Colonna relativa e questo parametro */
+    column?: string;
+    /** Tipo del dizionario */
+    dictype?: string;
+    /** Indica un filtro da applicare nei confronti del Backend qualora si vogliano caricare solo le possibilità logicamente accettabili per questo parametro */
+    dictionaryfilter?: string;
+    /** Tipologia lato "typescript" di questo parametro, dev'essere sempre logicamente congruente al **typecode** */
+    type?: "string" | "number" | "date" | "boolean";
+    /** Eventuale pattern di validazione per questo parametro */
+    pattern?: string;
+}
+
+/** Classe che rappresenta una colonna di un report */
+declare class ReportColumn {
+    /** Id della colonna */
+    id: string;
+    /** Descrizione della colonna (Header) */
+    description: string;
+    /** Colore in notazione HTML */
+    color: string;
+    /** Tipo di campo contenuto in questa colonna */
+    type: number;
+    /** Sequenza per eventuali ordinamenti */
+    seq: number;
+    /** Ordinamento dei dati presentati */
+    order?: string;
+    /** Allineamento da tenere per questa colonna: **Center**, **Left** o **Right** */
+    alignment?: string;
+    /** Formato dei dati da presentare in questa colonna */
+    format?: string;
+}
+
+/**
+ * Classe che identifica una ricerca paginata in tutte le sue sfumature (di grigio)
+ */
+declare class AppSearch<T> {
+    /**
+     * Costruttore che genera un'istanza coi valori di default e impostando **firstsearch** a **true**
+     */
+    constructor();
+    /** ID della ricerca, sempre inutile a meno che non sia la ricerca dei risultati di un report */
+    searchid: string;
+    /** Descrizione della ricerca, sempre inutile a meno che non sia la ricerca dei risultati di un report */
+    searchdescription: string;
+    /** Indica se la paginazione per questa ricerca è disponibile */
+    pagingavailable: boolean;
+    /** Indica il formato di export disponibile per questa ricerca. Utilizzato solo per la ricerca dei risultati di un report */
+    expformat: boolean;
+    /** Parametri di ricerca per i risultati in modalità report */
+    pars: ReportParam[];
+    /** Indicazione delle colonne presenti nel report */
+    report_columns: ReportColumn[];
+    /** Indica se c'è una ricerca in corso */
+    searchinprogress: boolean;
+    /** Indica il numero totale di pagine trovate dalla ricerca. Ogni pagina è una lista di **itemsperpageoverride** oggetti */
+    pages: number;
+    /** Conteggio totale degli oggetti trovati (inclusi quelli in pagine non attualmente selezionate) */
+    objectcount: number;
+    /** Conteggio totale dei gruppi trovati (inclusi quelli in pagine non attualmente selezionate) */
+    groupcount: number;
+    /** Pagina attualmente in visualizzazione */
+    page: number;
+    /** Numero di oggetti da persentare in ogni pagina. Per convenzione si considera valorizzato a 15 se non fornito */
+    itemsperpageoverride: number;
+    /** Lista degli oggetti nella pagina attualmente in visualizzazione */
+    items: T[];
+    /** Dizionario contenente tutti i gruppi paginati  */
+    groups: Group[];
+    /** Lista di colonne per cui ordinare */
+    orders: AppOrdering[];
+    /** Lista di colonne da visualizzare */
+    columns: string[];
+    /** Lista di colonne nell'ordine corretto */
+    column_ordering: string[];
+    /** Indica se la ricerca era salvata. Qualora fosse questo il caso, al caricamento l'es-table si occuperà di ri-effettuare la ricerca ed aggiornare il modello */
+    savedstate: boolean;
+    /** Indica se bisogna ancora effettuare la prima ricerca */
+    firstsearch: boolean;
+    /** Indica se sto effettuando la ricerca post bind */
+    selfsearch: boolean;
+    /**
+     * Oggetto che indica la selezione corrente.
+     *
+     * Se **all** è **true** vuole dire che è tutto selezionato ed eventualmente ci sono delle esclusioni (**exclusions**)
+     * Se **all** è **false** vuol dire che sono selezionati **item** specifici
+     *
+     * In base all'Input **UseSelectionCache** le proprietà **exclusions** e **items** fanno riferimento o alla pagina corrente (se **false**)
+     * o all'intera ricerca (se **true**)
+     */
+    selection: ItemsSelection<T>;
+    /**
+     * Indica che la ricerca è stata richiesta dall'estable. Questa variabile NON deve essere toccata. È gestita al 100% dall'es-table.
+     *
+     * L'unica cosa che serve è che nel modello lato C# sia presente in modo da non perderla durante la serializzazione
+     */
+    internalsearchrequest: boolean;
+    /** Raggruppamenti da fare per questa query. Se impostato e non ci sono **filtergroup** mi aspetto di ricevere oggetti nel campo **groups** */
+    groupings: GroupOrAggregation[];
+    /**
+     * Filtro da applicare ai gruppi. Qualora il numero di filtri qui fosse uguale al numero di raggruppamenti mi inizio ad apettare di ricevere oggetti
+     * sul campo **items**, in caso contrario mi aspetto di ricevere o i gruppi nel campo **groups** o l'N-esimo livello dei gruppi
+     */
+    requestedgroups: GroupFilter[];
+    /**
+     * Permette di resettare un AppSearch ai valori di default.
+     * Reso statico perché fra una deserializzazione e l'altra si potrebbe perdere il prototype del costruttore
+     *
+     * @param {AppSearch<T>} aps AppSearch da resettare
+     */
+    static reset<T extends AppSearch<any>>(aps: T): void;
+    /**
+     * Partendo da un appsearch con filtri impostati permette di crearne la stessa versione solo con la ricerca impostata a "tutto"
+     *
+     * @param {AppSearch<T>} aps AppSearch da cui partire
+     */
+    static toSelectAll<T extends AppSearch<any>>(aps: T): T;
+    /**
+     * Permette di ottenere un nuovo riferimento all'AppSearch passata come parametro.
+     * Internamente utilizza il JSON.parse(JSON.stringify(X)) con la differenza che prima stacca il riferimento agli items per evitare di
+     * reserializzare potenzialmente centinaia di elementi. Il riferimento viene poi ricollegato alla nuova appsearch generata
+     *
+     * @param {AppSearch<T>} aps AppSearch di cui estrarre un nuovo riferimento equivalente
+     */
+    static newref<T extends AppSearch<any>>(aps: T, retainItems?: boolean): T;
+}
+
+/** Tipo che rappresenta gli input visualizzabili lato tabella */
+type InputType = 'string' | 'float' | 'date' | 'number' | 'int' | 'boolean' | 'enum' | 'autocomplete' | 'datetime' | 'time' | 'file' | 'currency';
+
+/** Classe che identifica una colonna. Utilizzata in modalità "Colonne dinamiche" */
+declare class EsTableColumnsDefinition {
+    Description: string;
+    PropertyName: string;
+    RoutePath: string;
+    RouteParameterProperties: string[];
+    DataOrder: 'ASC' | 'DESC';
+    ColumnOrder: number;
+    Visible: boolean;
+    Clss: string;
+    Orderable: boolean;
+    HeaderWraps: boolean;
+    PropertyType: InputType | string;
+    PropertySource: {
+        id: string;
+        description: string;
+    }[];
+    EditorName: string;
+    RendererName: string;
+    EditorOptions: {
+        [id: string]: any;
+    };
+    Pinned: boolean;
+    PinnedWidth: number;
+    Pinnable: boolean;
+    Grouping: string;
+    Shrink: boolean;
+    /**
+     * Costruttore
+     *
+     * @param {string} Description Descrizione della colonna
+     * @param {string} PropertyName Nome della proprietà del modello in cui sono contenuti i dati da visualizzare per questa colonna
+     * @param {string} RoutePath Route di navigazione. Es. "['/pages/mod/mod_detail', { 'idItem': '{0}', 'idItem2' : '{1}' }]"
+     * @param {string[]} RouteParameterProperties Proprietà da bindare a **routePath** per generare la route completa.
+     * L'indice scritto in **routePath** è l'indice di accesso a questo array. Es. ["iditem", "iditem2"]
+     * @param {'ASC' | 'DESC' } DataOrder Ordinamento dei dati presentati in questa colonna
+     * @param {number} ColumnOrder Ordinamento di questa colonna
+     * @param {boolean} Visible Visibilità o meno della colonna
+     * @param {string} Clss Classe da applicare sia ai TD che ai TH relativi a questa colonna
+     * @param {boolean} Orderable Indica se la colonna è ordinabile o no (nel senso ASC / DESC / NONE)
+     * @param {boolean} HeaderWraps Indica se il testo dell'header dev'essere wrappato all'interno del th. Di default no.
+     * @param {InputType | string} PropertyType Indica il tipo della proprietà identificata da **propertyName**.
+     * @param {{id: string, description: string}[]} PropertySource Sorgente dati su cui autocompletare/scegliere il valore per la proprietà **propertyName**, ha senso solo per **propType** enum o autocomplete.
+     * @param {string} EditorName Nome dell'editor da utilizzare per la modifica di questo campo
+     * @param {string} RendererName Nome del renderer da utilizzare per visualizzare questo campo
+     */
+    constructor(Description: string, PropertyName: string, RoutePath?: string, RouteParameterProperties?: string[], DataOrder?: 'ASC' | 'DESC', ColumnOrder?: number, Visible?: boolean, Clss?: string, Orderable?: boolean, HeaderWraps?: boolean, PropertyType?: InputType | string, PropertySource?: {
+        id: string;
+        description: string;
+    }[], EditorName?: string, RendererName?: string, EditorOptions?: {
+        [id: string]: any;
+    }, Pinned?: boolean, PinnedWidth?: number, Pinnable?: boolean, Grouping?: string, Shrink?: boolean);
+    static build(parsObj: any): EsTableColumnsDefinition;
+}
+
+/** Indica un'opzione cliccabile nel Corner Menù della tabella (il menù richiamabile dai 3 pallini verticli in alto a destra) */
+declare class CornerMenuOption {
+    /** Id dell'operazione. I callback relativi verranno effettuati con questo */
+    id: string;
+    /** Descrizione dell'operazione da presentare all'utente */
+    description: string;
+}
+
+/** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
+declare class EsTableOperationDefinition {
+    id: string;
+    title: string;
+    iconClass?: string;
+    text?: string;
+    conditionField?: string;
+    conditionValue?: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} id Codice dell'operazione
+     * @param {string} title Titolo dell'operazione, da presentare all'utente su hover della cella
+     * @param {string} iconClass Classe che fornisca un iconcina Es. "fa fa-remove"
+     * @param {string} text Eventuale testo presentato nella cella, genericamente va in alternativa a **iconClass**
+     * @param {string} conditionField Indica il campo dell'oggetto sottostante su cui verificare la visibilità o meno di questa icona
+     * @param {string} conditionValue Indica il valore che la proprietà **conditionField** dell'oggetto sottostante deve assumere affinché questa opzione si veda
+     */
+    constructor(id: string, title: string, iconClass?: string, text?: string, conditionField?: string, conditionValue?: string);
+}
+
+/** Definizione di una colonna, utilizzato nella dialog che permette di modificare le posizioni e le visibilità */
+declare class EsTableColumn {
+    id: string;
+    description: string;
+    visible?: boolean;
+    fixed?: boolean;
+    pinned?: boolean;
+    pinnable?: boolean;
+    pinnedWidth?: number;
+    template?: TemplateRef<any>;
+    parentTemplates?: {
+        id: string;
+        tmpl?: TemplateRef<any>;
+        content?: string;
+    }[];
+    multi?: boolean;
+    multiContent?: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} id Id colonna
+     * @param {string} description Descrizione (Header)
+     * @param {boolean} visible Indica se di default mostrarla o meno
+     * @param {boolean} fixed Indica se è una colonna fixed
+     * @param {boolean} pinnable Indica se una colonna può essere pinnata
+     * @param {boolean} pinned Indica se è una colonna pinnata
+     * @param {number} pinnedWidth Indica la dimensione da assegnare a questa colonna quando è pinnata
+     * @param {TemplateRef<any>} template Indica il template da usare per mostrare il testo dell'Header
+     * @param {{ id: string, tmpl: TemplateRef<any>, content: string }[]} parentTemplates Indica la lista di template padri collegata a questo header, rappresentati come Template o come stringa qualora fosse generato automaticamente (caso **Multi**)
+     * @param {boolean} multi Indica che la colonna deriva da una direttiva **Multi**
+     * @param {string} multiContent Indica il contenuto della direttiva **Multi** per questa colonna
+     */
+    constructor(id: string, description: string, visible?: boolean, fixed?: boolean, pinned?: boolean, pinnable?: boolean, pinnedWidth?: number, template?: TemplateRef<any>, parentTemplates?: {
+        id: string;
+        tmpl?: TemplateRef<any>;
+        content?: string;
+    }[], multi?: boolean, multiContent?: string);
+    /** Indice precedente in cui si trovava questa colonna in modo da poterla spinnare in maniera super sexy */
+    prev_index: number;
+}
+
+/**
+ * Classe che rappresenta un singolo frammento di route di un elemento gruppo o non. Un array di questi indica tutte le colonne di gruppo con i loro valori
+ * per arrivare ad una ricerca su sottogruppi o elementi relativi
+ */
+declare class GroupRouteFragment {
+    column: string;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column Colonna di raggruppamento
+     * @param {string} value Valore della colonna di raggruppamento
+     */
+    constructor(column: string, value: string);
+}
+
+/** Classe che rappresenta un separatore da inserire fra gli oggetti dell'es-table per le operazioni di paginazione dei raggruppamenti per riga */
+declare class GroupPager {
+    _grouplevel: number;
+    _thisRoute: GroupRouteFragment[];
+    _parent: string;
+    view: AppSearch<any>;
+    searches: 'groups' | 'items';
+    /**
+     * Costruttore
+     *
+     * @param {number} _grouplevel Livello del gruppo a cui questo separatore fa riferimento
+     * @param {string} _thisRoute Route che identifica la gerarchia del gruppo e chi sono i parent
+     * @param {string} _parent Chiave del gruppo parent se esiste
+     * @param {AppSearch<any>} view Vista di ricerca collegata a questo elemento
+     * @param {'groups' | 'items'} searches Indica che cosa cerca questo separatore, se sottogruppi o oggetti
+     */
+    constructor(_grouplevel: number, _thisRoute: GroupRouteFragment[], _parent: string, view: AppSearch<any>, searches: 'groups' | 'items');
+    /** Indica che è un separatore, sempre impostato a **true** */
+    _sep: boolean;
+    /** Array dei pulsanti da collegare lato interfaccia per le paginazione */
+    buttons: any[];
+    /** Chiave del separatore, è sempre **parent** + "_sep" */
+    _thisKey: string;
+}
+
+/**
+ * @ignore Interfaccia di passaggio fra i dati che arrivano come direttiva / configurazione alla struttura interna su cui vengono generati i componenti es-th
+ *
+ * Per informazioni sulle singole proprietà fare riferimento alla direttiva **EsThDirective**
+ */
+interface ThElement {
+    Pinned: boolean;
+    Fixed: boolean;
+    PinnedWidth: number;
+    ID: string;
+    Visible: boolean;
+    Class: string;
+    Content: string;
+    Order: string;
+    Orderable: boolean;
+    Template: TemplateRef<any>;
+    Wrap: boolean;
+    LeftBorder: boolean;
+    RightBorder: boolean;
+    Multi: boolean;
+    MultiContent: string;
+    Alignment: string;
+}
+
+/** Classe che rappresenta le informazioni di paginazione della tabella attuale */
+declare class PagerInfos {
+    constructor();
+    PagerCount: number;
+    ShowCount: boolean;
+    ShowPaging: boolean;
+    UsesView: boolean;
+    ShowButtons: boolean;
+    ShowPagingOptions: boolean;
+    View: any;
+    Ready: boolean;
+    Searches: 'items' | 'groups';
+}
+
+/** Interfaccia che indica un Header rappresentanto un gruppo */
+interface ThGroup {
+    /** Codice autogenerato essenzialmente per gli ngFor - trackBy */
+    ID: string;
+    /** Span di questo gruppo */
+    Span: number;
+    /** Template da visualizzare dentro al gruppo */
+    Template: TemplateRef<any>;
+}
+
+/** Interfaccia di passaggio fra i dati che arrivano come direttiva / configurazione alla struttura interna su cui vengono generati i componenti es-td */
+interface TdElement {
+    /** Id della cella, dev'essere lo stesso della colonna **EsTh** relativa */
+    ID: string;
+    /** Indica se è una cella interna (rigenerata programmaticamente) o no */
+    Internal?: boolean;
+    /** RouterLink qualora il click su questa cella debba navigare da qualche parte */
+    RouterLink?: any;
+    /** Valore da mostrare all'interno della cella. Se omesso verrà proiettato il contenuto dal template in cui è stata usata */
+    Display?: string;
+    /** Template Angular da istanziare per questo TD */
+    Template?: any;
+    /** Classi da applicare alla cella */
+    Class?: string;
+    /** Contenuto da mostrare proiettato dal componente padre */
+    Content?: SafeHtml;
+    /** Contesto dell'oggetto a cui si riferisce il dato visualizzato. Contiene l'hash dell'oggetto in questione */
+    Context?: string;
+    /** Indica se aggiungere un bordino a sinistra della cella */
+    LeftBorder?: boolean;
+    /** Indica se aggiungere un bordino a destra della cella */
+    RightBorder?: boolean;
+    /** Indica se è una cella pinnata */
+    Pinned?: boolean;
+    /** Indica la larghezza della cella qualora fosse pinnata */
+    PinnedWidth?: number;
+    /** Indica se la cella è l'header di un gruppo */
+    GroupHeader?: boolean;
+    /** Indica se la cella è un'aggregazione di un gruppo */
+    GroupAggregation?: boolean;
+    /** Indica se la cella è visibile, ereditata dalla controparte es_th */
+    Visible?: boolean;
+    /** Indica se la cella deve wrappare o no il contenuto */
+    Wraps?: boolean;
+    /** Nome della proprietà JS che questa cella mostra */
+    PropertyName?: string;
+    /** Tipo della proprietà **PropertyName** */
+    PropertyType?: string;
+    /** Sorgente dati per la valorizzazione della proprietà **PropertyName** */
+    PropertySource?: {
+        id: string;
+        description: string;
+    }[];
+    /** Indica che l'oggetto di bindare per questo td è l'elemento all'indice Y della proprietà Z dove Y e Z vengono prese dall'**ID** scritto come Z_Y */
+    Multi?: true;
+    /** Indica l'eventuale proprietà a cui accedere nel caso sia **Content** che **Template** siano vuoti */
+    PropAccessor?: string;
+    /** Se il contenuto di questo td dev'essere un'immagine cliccabile, questa è la classe che la identifica */
+    IconClass?: string;
+    /** Campo da controllare per fare apparire/sparire il contenuto di questa cella qualora fosse diverso da **ConditionValue** */
+    ConditionField?: string;
+    /** Valore che deve assumere **ConditionField** per mostrare il contenuto di questa cella */
+    ConditionValue?: string;
+    /** Titolo HTML di questa cella */
+    Title?: string;
+    _editing?: boolean;
+    old_value?: any;
+}
+
+/** Classe che rappresenta la modifica ad un singolo oggetto in una singola proprietà */
+declare class EsTableModelChange {
+    item: any;
+    header: string;
+    property: string;
+    old_value: string;
+    new_value: string;
+    /**
+     * Costruttore
+     * @param {any} item Oggetto modificato
+     * @param {string} header Nome dell'Header che è stato modificato
+     * @param {string} property Nome della proprietà modificata
+     * @param {string} old_value Vecchio valore della proprietà **property** dell'oggetto **item**
+     * @param {string} new_value Nuovo valore della proprietà **property** dell'oggetto **item**
+     */
+    constructor(item: any, header: string, property: string, old_value: string, new_value: string);
+}
+
+/** Classe che rappresenta il riferimento ad una proprietà di un oggetto bindato sulla tabella */
+declare class ItemPropEditableReference {
+    /** Stato di selezione della cella relativa */
+    selected: boolean;
+    /** Oggetto relativo su cui si modificano le proprietà */
+    item: any;
+    /** ID dell'header in modifica (riferimento al TH relativo) */
+    header: string;
+    /** Proprietà Javascript effettivamente in modifica */
+    property: string;
+    /** Tipo dell'input */
+    type: InputType | string;
+    /** Valore attuale della proprietà **property** dell'oggetto **item** */
+    value: string;
+    /** Indica se la cella deve avere il bordino a sinistra */
+    lborder?: boolean;
+    /** Indica se la cella deve avere il bordino in alto */
+    tborder?: boolean;
+    /** Indica se la cella deve avere il bordino a destra */
+    rborder?: boolean;
+    /** Indica se la cella deve avere il bordino in basso */
+    bborder?: boolean;
+    /** Indica se il bordo a sinistra overlappa su un bordo di selezione destro della cella precedente */
+    loverlaps?: boolean;
+    /** Indica se il bordo a destra overlappa su un bordo di selezione sinistro della cella successiva */
+    roverlaps?: boolean;
+    /** Indica se il bordo in alto overlappa su un bordo di selezione basso della cella precedente */
+    toverlaps?: boolean;
+    /** Indica se il bordo in basso overlappa su un bordo di selezione in alto della cella successiva */
+    boverlaps?: boolean;
+    /** Funzione che imposta il nuovo valore della proprietà **property** dell'oggetto **item** ed aggiorna il **value** di questo oggetto */
+    val_setter?: (value: string) => any;
+}
+
+/** Raccolta di tutti gli Input dell'EsTable a cui può essere logicamente sensato assegnare default per progetto */
+declare class EsTableDefaultable {
+    /**  @ignore Vedi **EsTableComponent** */ ColumnsResizable?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ AutoUpdate?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ AllSearch?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ Export?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ HidePaging?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ HidePagingCount?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ HidePagingButtons?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ ContainerClass?: string;
+    /**  @ignore Vedi **EsTableComponent** */ TableClass?: string;
+    /**  @ignore Vedi **EsTableComponent** */ Selection?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ SavePreferences?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ PagingStyle?: 'both' | 'top' | 'bottom';
+    /**  @ignore Vedi **EsTableComponent** */ RowGroupingPagingStyle?: 'left' | 'right';
+    /**  @ignore Vedi **EsTableComponent** */ UseSelectionCache?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ ShowItemGroupsColumns?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ ArraymodeItemsPerPage?: number;
+    /**  @ignore Vedi **EsTableComponent** */ ColumnsPinnable?: boolean;
+    /**  @ignore Vedi **EsTableComponent** */ DefaultAlignment?: 'Left' | 'Center' | 'Right';
+}
+
+/** Componente rappresentante una singola cella del body della tabella */
+declare class EsTd {
+    el: ElementRef;
+    /** Id della cella, dev'essere lo stesso della colonna **EsTh** relativa */
+    ID: _angular_core.InputSignal<string>;
+    /** Contesto dell'oggetto a cui si riferisce il dato visualizzato. Contiene l'hash dell'oggetto in questione */
+    Context: _angular_core.InputSignal<string>;
+    /** Quando questa cella viene generata questo evento permette di dire "ehi, sono nato!"  */
+    onCellGeneration: EventEmitter<{
+        id: string;
+        hash: string;
+        self: EsTd;
+    }>;
+    /** Errore attualmente presente sulla cella */
+    ValidationError: _angular_core.WritableSignal<string>;
+    /** @ignore */
+    constructor(el: ElementRef);
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** Api per impostare un "errore" su questa cella in maniera programmatica */
+    validationError(error?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTd, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EsTd, "[es-td]", never, { "ID": { "alias": "es-td"; "required": false; "isSignal": true; }; "Context": { "alias": "Context"; "required": false; "isSignal": true; }; }, { "onCellGeneration": "onCellGeneration"; }, never, ["*"], false, never>;
+}
+
+/** Direttiva per la dichiarazione snella di un EsTd da emettere per ogni elemento, data una colonna */
+declare class EsTdDirective {
+    Template: TemplateRef<any>;
+    /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsTdComponent */
+    _directive: boolean;
+    /** Variabile interna che indica il fatto che questo template si riferisce a una proprietà multipla */
+    _multi: boolean;
+    /** Indica se la cella è visibile o meno di default */
+    tdVisible: boolean;
+    /** Id della colonna, fa riferimento al **th** padre */
+    td: string;
+    /** Se questo td viene usato come renderer in questa proprietà è scritto il nome della proprietà dell'oggetto bindato per cui fare apparire il **Template** */
+    tdForProperty: string;
+    /** Equivalente dell'NgIf sul td */
+    tdIf: boolean;
+    /** Eventuali classi da applicare al **td** generato */
+    tdClass: string;
+    /** In mancanza di **Template** indica qual è la proprietà dell'oggetto contenente le informazioni da mostrare */
+    tdPropertyAccessor: string;
+    /** Allineamento dei valori della tabella */
+    tdAlignment: "Center" | "Left" | "Right";
+    /** Formato da applicare al valore se applicabile, utilizzabile solo se **tdPropertyAccessor** è valorizzato */
+    tdFormat: string;
+    /** Se il contenuto di questo td dev'essere un'immagine cliccabile, questa è la classe che la identifica */
+    tdIconClass: string;
+    /** Campo da controllare per fare apparire/sparire il contenuto di questa cella qualora fosse diverso da **tdConditionValue** */
+    tdConditionField: string;
+    /** Valore che deve assumere **tdConditionField** per mostrare il contenuto di questa cella */
+    tdConditionValue: string;
+    /** Titolo HTML di questa cella */
+    tdTitle: string;
+    /** Contenuto statico di questa cella */
+    tdContent: string;
+    /**
+     * @ignore
+     */
+    constructor(Template: TemplateRef<any>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTdDirective, [{ self: true; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EsTdDirective, "[td]", never, { "tdVisible": { "alias": "tdVisible"; "required": false; }; "td": { "alias": "td"; "required": false; }; "tdForProperty": { "alias": "tdForProperty"; "required": false; }; "tdIf": { "alias": "tdIf"; "required": false; }; "tdClass": { "alias": "tdClass"; "required": false; }; "tdPropertyAccessor": { "alias": "tdPropertyAccessor"; "required": false; }; "tdAlignment": { "alias": "tdAlignment"; "required": false; }; "tdFormat": { "alias": "tdFormat"; "required": false; }; "tdIconClass": { "alias": "tdIconClass"; "required": false; }; "tdConditionField": { "alias": "tdConditionField"; "required": false; }; "tdConditionValue": { "alias": "tdConditionValue"; "required": false; }; "tdTitle": { "alias": "tdTitle"; "required": false; }; "tdContent": { "alias": "tdContent"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/** Classe rappresentante una singola aggregazione effettuata su una colonna */
+declare class ThAggregation {
+    func: 'min' | 'max' | 'sum';
+    format: string;
+    match: string;
+    /**
+     * Costruttore
+     *
+     * @param {'min' | 'max' | 'sum'} func Funzione di aggergazione, può essere **min**, **max** o **sum**
+     * @param {string} format Formato richiesto per il valore dell'aggregazione
+     * @param {string} match Match intero del pezzo di testo da cui si è estrapolata l'aggregazione, da rimpiazzare col valore calcolato
+     */
+    constructor(func: 'min' | 'max' | 'sum', format: string, match: string);
+}
+
+/** Direttiva per la dichiarazione snella di un EsTh da emettere come header */
+declare class EsThDirective {
+    Template: TemplateRef<any>;
+    /** Variabile interna all'interno della quale viene raccolta la cache delle aggregazioni specificate in thAggregation */
+    _thAggregations: ThAggregation[];
+    /** Variabile interna contenente in maniera ordinata i template dei padri */
+    _thParents: {
+        id: string;
+        tmpl?: TemplateRef<any>;
+        content?: string;
+    }[];
+    /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsThComponent */
+    _directive: boolean;
+    /** Variabile interna impostata dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
+    _referenced: boolean;
+    /** Variabile interna che indica il fatto che questo template si riferisce a una proprietà multipla */
+    _multi: boolean;
+    /** Variabile interna che indica il contenuto dell'header in caso di multi */
+    _multi_content: string;
+    /** Id della colonna, dev'essere lo stesso per tutti i **td** relativi */
+    th: string;
+    /** Indica se la colonna è pinnata o no */
+    thPinned: boolean;
+    /** Indica se la colonna è pinnabile o no */
+    thPinnable: boolean;
+    /** Indica le dimensioni che deve avere questa colonna quando viene pinnata, senza questo tutte le colonne mi collasserebbero l'una sull'altra */
+    thPinnedWidth: number;
+    /** Indicazione sulla visibilità della colonna */
+    thVisible: boolean;
+    /** Indica se la colonna è fixed, cioè se non può né essere nascosta, né riposizionata. Solo le prime colonne possono essere Fixed */
+    thFixed: boolean;
+    /** Indica che la colonna è sotto ad un raggruppamento padre, con questo nome nel **th** */
+    thParent: string;
+    /** Ordinamento attuale della colonna */
+    thOrder?: 'DESC' | 'ASC';
+    /** Indica se questa colonna è ordinabile o meno */
+    thOrderable: boolean;
+    /** Indica se il testo presente in questo Header può andare a capo o meno, di default non può */
+    thWrap: boolean;
+    /** Indica se le dimnsioni di questa colonna sono modificabili o meno */
+    thResizable: boolean;
+    /** Classi da applicare all'Header della colonna */
+    thClass: string;
+    /** Classi da applicare all'Header della colonna */
+    thShrink: boolean;
+    /** Classi da applicare alle righe quando rappresentano un Gruppo */
+    thGroupClass: string;
+    /** Equivalente dell'NgIf sul th */
+    thIf: boolean;
+    /** Campo particolare che indica che questo header è vuoto. Viene utilizzato solo a livello grafico per ignorare o meno l'emit del template */
+    thEmpty: boolean;
+    /** Indica che bisogna fare un raggruppamento su questa colonna */
+    thGroup: boolean;
+    /** Indica che bisogna fare una aggregazione su questa colonna, a fronte di almeno un altra con un raggruppamento */
+    thAggregation: string;
+    /** Proprietà JS a cui si riferisce questa cella */
+    thProperty: string;
+    /** Tipo della proprietà JS a cui si riferisce questa cella. Se valorizzato l'utente la potrà modificare facendo doppio click */
+    thType: InputType | string;
+    /** Sorgente dei valori disponibili per questa cella se il **Type** è di tipo 'enum' */
+    thSource: {
+        id: string;
+        description: string;
+    }[];
+    /** Indica che questo header deve essere emesso una volta per ogni valore presente nella lista di **EsTableMultiValue** alla proprietà **th** dell'oggetto corrente */
+    thMulti: boolean;
+    /** Indica un contenuto statico da mostrare piuttosto che utilizzare il **Template**. Serve in caso questo oggetto venga generato programmaticamente */
+    thStaticContent: string;
+    /** Colore del background della cella */
+    thBackgroundColor: string;
+    /** Allineamento dei valori della tabella */
+    thAlignment: "Center" | "Left" | "Right";
+    /** Formato da applicare al valore se applicabile */
+    thFormat: string;
+    /** Nome dell'editor da utilizzare per la modifica di questo campo, ordine di priorità:
+     *
+     * 1. Editor con nome **thEditorName**
+     *
+     * 2. Editor riferito alla proprietà **thProperty**
+     *
+     * 3. Editor di default per **thType**
+     */
+    thEditorName: string;
+    /** Opzioni da applicare all'editor di questa colonna */
+    thEditorOptions: {
+        [id: string]: any;
+    };
+    /** Nome del renderer da utilizzare per visualizzare questo campo. Utilizzato solo per le tabelle dinamiche */
+    thRendererName: string;
+    /** Route di navigazione. Es. "['/pages/mod/mod_detail', { 'idItem': '{0}', 'idItem2' : '{1}' }]" */
+    thRoutePath: string;
+    /**
+     * Proprietà da bindare a **routePath** per generare la route completa.
+     *
+     * L'indice scritto in **routePath** è l'indice di accesso a questo array. Es. ["idItem", "idItem2"]
+     */
+    thRouteParameterProperties: string[];
+    /** @ignore */
+    constructor(Template: TemplateRef<any>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsThDirective, [{ self: true; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EsThDirective, "[th]", never, { "th": { "alias": "th"; "required": false; }; "thPinned": { "alias": "thPinned"; "required": false; }; "thPinnable": { "alias": "thPinnable"; "required": false; }; "thPinnedWidth": { "alias": "thPinnedWidth"; "required": false; }; "thVisible": { "alias": "thVisible"; "required": false; }; "thFixed": { "alias": "thFixed"; "required": false; }; "thParent": { "alias": "thParent"; "required": false; }; "thOrder": { "alias": "thOrder"; "required": false; }; "thOrderable": { "alias": "thOrderable"; "required": false; }; "thWrap": { "alias": "thWrap"; "required": false; }; "thResizable": { "alias": "thResizable"; "required": false; }; "thClass": { "alias": "thClass"; "required": false; }; "thShrink": { "alias": "thShrink"; "required": false; }; "thGroupClass": { "alias": "thGroupClass"; "required": false; }; "thIf": { "alias": "thIf"; "required": false; }; "thEmpty": { "alias": "thEmpty"; "required": false; }; "thGroup": { "alias": "thGroup"; "required": false; }; "thAggregation": { "alias": "thAggregation"; "required": false; }; "thProperty": { "alias": "thProperty"; "required": false; }; "thType": { "alias": "thType"; "required": false; }; "thSource": { "alias": "thSource"; "required": false; }; "thMulti": { "alias": "thMulti"; "required": false; }; "thStaticContent": { "alias": "thStaticContent"; "required": false; }; "thBackgroundColor": { "alias": "thBackgroundColor"; "required": false; }; "thAlignment": { "alias": "thAlignment"; "required": false; }; "thFormat": { "alias": "thFormat"; "required": false; }; "thEditorName": { "alias": "thEditorName"; "required": false; }; "thEditorOptions": { "alias": "thEditorOptions"; "required": false; }; "thRendererName": { "alias": "thRendererName"; "required": false; }; "thRoutePath": { "alias": "thRoutePath"; "required": false; }; "thRouteParameterProperties": { "alias": "thRouteParameterProperties"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/** Direttiva che rappresenta il template dell'editor di una cella all'interno della tabella */
+declare class EsTdEditorDirective {
+    Template: TemplateRef<any>;
+    /** Id dell'Editor */
+    editor: string;
+    /** In questa proprietà è scritto il nome della proprietà dell'oggetto bindato per cui fare apparire il **Template** */
+    editorForProperty: string;
+    /** @ignore */
+    constructor(Template: TemplateRef<any>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTdEditorDirective, [{ optional: true; self: true; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EsTdEditorDirective, "[editor]", never, { "editor": { "alias": "editor"; "required": false; }; "editorForProperty": { "alias": "editorForProperty"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ThTdProvider {
+    EsTdsDirective: QueryList<EsTdDirective>;
+    EsThsDirective: QueryList<EsThDirective>;
+    LoadedSignal: ReplaySubject<void>;
+    setLoaded(): void;
+    asyncLoad(): Promise<void>;
+    ngOnInit(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThTdProvider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThTdProvider, "[td_th_provider]", ["tdThProvider"], {}, {}, ["EsTdsDirective", "EsThsDirective"], never, false, never>;
+}
+
+/** Classe contenente la gestione delle importazioni */
+declare class ExportHandler {
+    private est;
+    private expExts;
+    private msgExts;
+    private utiExts;
+    private dateExts;
+    private exportInProgress;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent, expExts: ExportService, msgExts: MessageService, utiExts: UtilityService, dateExts: DateService);
+    /**
+     * Effettua l'esportazione dei dati
+     *
+     * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
+     */
+    tryExport(format?: 'CSV' | 'XLSX'): void;
+}
+
+/** Classe di utilità per le cose comuni */
+declare class UtilitiesHandler {
+    private hashExts;
+    /** @ignore Costruttore */
+    constructor(hashExts: HashingService);
+    /**
+     * Data una lista di oggetti effettua dei raggruppamenti in base alla proprietà **field**,
+     * restituendo un oggetto del tipo { Gruppo1: oggetti[], Gruppo2: oggetti[], ecc... }
+     *
+     * @param {any[]} array Lista degli oggetti da raggruppare
+     * @param {string} field Campo su cui effettuare i raggruppamenti
+     *
+     * @returns {{ [id: string]: any[] }} Dizionario dei gruppi
+     */
+    groupBy(array: any[], field: string): {
+        [id: string]: any[];
+    };
+    /**
+     * Helper per effettuare il caching delle aggregazioni. Le sposta da una lista di **GroupAggregation** a una **<Map<string, Map<string, string>>**
+     *
+     * @param {any} group Gruppo di cui cachare le aggregazioni
+     */
+    cacheAggregations(group: any): void;
+    /** Helper per spostare un oggetto di un array da un indice all'altro, in place */
+    arrayMove(array: any[], oldI: number, newI: number): void;
+    /**
+     * Date le informazioni di paginazione ottiene l'array dei pulsanti
+     *
+     * @param {number} maxBtns Numero massimo di pulsanti da visualizzare
+     * @param {number} page Pagina corrente
+     * @param {number} lastPage Ultima pagina disponibile
+     *
+     * @returns {any[]} Pseudo-array di pulsanti a cui ci si può bindare lato HTML
+     */
+    getPagesArray(maxBtns: number, page: number, lastPage: number, actualCount?: number, ipp?: number): {
+        val: number;
+        cssClass: string;
+    }[];
+    /**
+     * Calcola l'hash di un oggetto qualsiasi
+     *
+     * @param {any[]} items Oggetti per cui calcolare l'hash
+     */
+    calculateHash(items: any[]): void;
+    /**
+    * Se l'Input è null (valore non settato) vede se c'è un default con cui valorizzarlo. Se non c'è utilizza il valore di fallback (qualora fornito)
+    *
+    * @param {T} inputValue Valore dell'Input
+    * @param {T} defaultValue Valore di default impostato da configurazione
+    * @param {T} fallbackValue Valore dell'Input per quando non è stato assegnato dal programmatore e non ha un default
+    */
+    InputOrDefault<T>(inputValue: T, defaultValue: T, fallbackValue?: T): T;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UtilitiesHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UtilitiesHandler>;
+}
+
+/** Classe che gestisce la modalità Row Grouping dell'es-table */
+declare class RowGroupingHandler {
+    private est;
+    private utilities;
+    private dateExts;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */
+    rgGroupCache: Map<string, Group>;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    rgItemCache: Map<string, any[]>;
+    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+    rgChildGroupsCache: Map<string, Group[]>;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler, dateExts: DateService);
+    /**
+     * In modalità rowgrouping quando mi arriva un nuovo blocco di oggetti devo aggiungerlo alla vista attuale:
+     *
+     * 1) Se non viene richiesto il dettaglio di alcun gruppo significa che devo considerare mi siano arrivati tutti i gruppi principali
+     * 2) Se viene richiesto il dettaglio di un gruppo diverso dall'ultimo devo aggiungere dopo al gruppo cliccato la lista dei sottogruppi
+     * 2) Se viene richiesto il dettaglio dell'ultimo gruppo devo aggiungere dopo al gruppo cliccato la lista degli oggetti
+     *
+     * @param {any} view AppSearch<T> da cui sono arrivati gli oggetti
+     * @param {number} groupingKeys Livelli di raggruppamento da aspettarsi sui dati
+     */
+    handleNewDataOnRowGrouping(view: AppSearch<any>, groupingKeys: number): void;
+    /**
+     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
+     *
+     * @param {ths: EsThDirective[]} ths Header
+     */
+    arrayModeReviewGroupings(ths: EsThDirective[]): void;
+    /**
+     * Data una direttiva EsTh restituisce la lista delle aggregazioni richiesta per questa colonna o il gruppo che rappresenta
+     *
+     * @param {EsThDirective} th Direttiva
+     *
+     * @returns {GroupOrAggregation[]} Lista dei gruppi o aggregazioni relativi alla Direttiva passata
+     */
+    getGroupAggregations(th: EsThDirective): GroupOrAggregation[];
+    /**
+    * Data una direttiva con un formato restituisce tutte le coppie Funzione di Aggregazione - Formato
+    *
+    * @param {EsThDirective} th Direttiva EsTh di cui calcolare le funzioni di aggregazione usate
+    *
+    * @returns {{ func: string, format: string }[]} Lista delle funzioni di aggregazione rilevate
+    */
+    private getEsThDirectiveListOfAggregations;
+    /**
+     * Data la definizione dei gruppi da generare da una lista di oggetti, suddivide gli oggetti passati in gruppi e sottogruppi
+     *
+     * @param {Group[]} grps Definizione dei gruppi
+     * @param {number} currentIndex Indice di elaborazione. Al livello 0 ho tutti gli oggetti e devo generare i primi gruppi, a livello 1 ho tutti i gruppi principali e devo
+     * elaborare i sottogruppi, e così via ricorsivamente...
+     * @param {any[]} items Oggetti da raggruppare
+     * @param {GroupOrAggregation[]} aggregations Info di aggregazione
+     * @param {any} parent Riferimento al gruppo padre
+     */
+    private getGroupsRecursive;
+    /**
+     * Data una lista di oggetti genera le aggregazioni specificate. Si considera di avere tutti gli oggetti
+     *
+     * @param {any[]} items Oggetti di cui calcolare le aggregazione
+     * @param {GroupOrAggregation[]} aggregations Aggergazioni da generare
+     */
+    private generateAggregations;
+    /**
+    * Ottiene un elemento di separazione fra Gruppi che serve per paginare le ricerche all'interno di ogni singolo gruppo
+    *
+    * @param {AppSearch<any>} view View utilizzata per la ricerca. Me ne salvo i parametri nel separatore attuale dato che ne ho bisogno per caricare altri elementi
+    * facenti riferimento allo stesso contesto
+    * @param {string} parent Parent path che rappresenta a quale gruppo è affibbiato questo separatore
+    * @param {GroupRouteFragment[]} route Route path che rappresenta a quale gruppo è affibbiato questo separatore
+    * @param {number} level Livello del gruppo di cui questo elemento è separatore, viene usato per applicare la classe "est-lvl-{{level}}"
+    *
+    * @returns {any} Elemento di separazione contenente tutti i bind per presentare una paginazione sotto questo gruppo lato interfaccia
+    */
+    getGroupSeparator(view: AppSearch<any>, parent: string, route: GroupRouteFragment[], level: number, searches: 'groups' | 'items'): GroupPager;
+    /**
+     * Data una colonna effettua la riemissione di tutte le ricerche relative.
+     *
+     * Es. Ho 2 campi di gruppo e ho espanso fino a vedere i valori fino ad un livello qualsiasi.
+     * Clicco l'ordinamento sul secondo gruppo.
+     * Tutte le ricerche relative ai primi gruppi devono essere rieseguite. Quando i risultati arriveranno ci penserà il metodo **bindDisplayToLoadedItemsOrGroups**
+     * a tagliare via gli oggetti non più visualizzati
+     *
+     * @param {string} column Colonna su cui si è effettuata un'operazione di ordinamento
+     * @param {AppOrdering[]} orderings Direttive di ordinamento da applicare alle varie sottoricerche
+     */
+    emitRowGroupingSearches(column: string, orderings: AppOrdering[]): void;
+    /**
+     * Helper che calcola il contenuto di una cella relativa a un gruppo riga, tenendo conto del formato delle eventuali aggregazioni
+     *
+     * @param {Group} grp Gruppo di cui mostrare le celle
+     * @param {string} cell Cella attuale di cui calcolare il testo
+     * @param {EsThDirective} header Header relativo alla cella attuale, utilizzata per identificare le informazioni di aggregazione
+     *
+     * @returns {string} Testo finale calcolato per la **cell** corrente, in base alle aggregazioni di **header**
+     */
+    getGroupCellDisplay(grp: Group, cell: string, header: EsThDirective): string;
+    /**
+     * Funzione che dato un valore lo formatta in base al tipo
+     *
+     * @param {string} value Valore che generalemnte può essere una data o un numero
+     * @param {string} fromat Formato su cui formattare il valore. Può essere ad esempio "small", "long" "verylong" per le date o F{0-9} per i numeri decimali
+     *
+     * @returns {string} Valore dell'aggregazione formattato come si deve
+     */
+    private formatAggregationValue;
+}
+
+/** Classe che gestisce tutte le informaizoni relative alle colonne: visibilità, posizione, stato di pin/unpin, ecc ecc... */
+declare class ColumnMetadataHandler {
+    private est;
+    private utilities;
+    private utiExts;
+    private prefService;
+    private rgH;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler, utiExts: UtilityService, prefService: PreferencesService, rgH: RowGroupingHandler);
+    /**
+     * Metodo che gestisce il cambio di Ordinamento di una colonna
+     *
+     * @param {string} id ID della colonna il cui oridnamento è cambiato
+     * @param {'DESC' | 'ASC'} order Nuovo ordine selezionato per la colonna
+     */
+    handleTHOrderChange(id: string, order: 'DESC' | 'ASC'): void;
+    /**
+     * Registra le preference relative alla view passata come parametro
+     *
+     * @param {any} castedView View di cui salvare colonne e ordinamento colonne
+     */
+    registerViewPreferences(castedView: AppSearch<any>): boolean;
+    /**
+     * Partendo dagli **EsThs** estrappolo la lista di **EsTableColumn** che questa tabella dovrà eventualmente gestire per Visibilità e Ordine
+     *
+     * Costo: 1 scan EsThs
+     *
+     * @param {EsThDirective[]} ths Colonne della tabella
+     */
+    reviewColumnsList(ths: EsThDirective[]): void;
+    /** In caso siano configurati dei th "Multi" (vedere la descrizione del campo **thMulti** di **EsThDirective**) questo metodo li "srotola" in tutti i th/td che devono effettivamente diventare */
+    expandMultiThsAndTds(ths: EsThDirective[], tds: EsTdDirective[], items: any[]): {
+        expThs: EsThDirective[];
+        expTds: EsTdDirective[];
+    };
+    /**
+     * Prende i th e i td in modalità diretive e li ordina in base a se ci sono colonne fixed o meno
+     */
+    moveFixedColumnsAtTheBeginning(ths: EsThDirective[], tds: EsTdDirective[]): void;
+    /** In base alla configurazione delle colonne calcola le dimenioni delle colonne pinnate */
+    evaluatePinnedColumnsWidth(): void;
+    /**
+     * Terminato il binding delle colonne da **reviewColumnsList** e della **View** dal **writeValue** questo metodo si occupa
+     * dell'allineamento delle informazioni fra le colonne calcolate internamente e le informazioni sulle colonne che arrivano dall'AppSearch
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    alignColumnsIfLoadedView(view: AppSearch<any>): void;
+    /**
+     * In base alla visibilità registrata nelle **ColumnsList** questo metodo si occupa di prendere tutti i **EsThDirective** ed **EsTdDirective** relativi e nasonderli/mostrarli
+     *
+     * Costo: 1 scan ColumnsList, 1 scan EsThDirectives, 1 scan EsTdDirectives
+     *
+     * @param {EsThDirective[]} ths Header della tabella
+     * @param {EsTdDirective[]} tds Celle della tabella
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    refreshColumnsVisibility(ths: EsThDirective[], tds: EsTdDirective[], view: AppSearch<any>): void;
+    /**
+     * Allinea gli ordinamenti dati fra le **EsThs** e le informazioni all'interno della View bindata
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     * @param {EsThDirective[]} ths Colonne della tabella
+     */
+    alignHeadersOrdering(ths: EsThDirective[], view: AppSearch<any>): void;
+    /**
+     * Genera tutte le informazioni che servono per gestire il raggruppamento degli header
+     *
+     * @param {EsThDirective[]} ths Colonne della tabella
+     *
+     * @returns {{ leafs: EsThDirective[], groupingLevel: number, parentsCache: any, thsCache: any }} Oggetto contenente la lista delle foglie (header base), il livello
+     * massimo di raggruppamento raggiunto, una cache in cui vengono indicati tutti i gruppi che sono "parent" (quindi che raggruppano almeno 1 header) e la cache degli header
+     */
+    evaluateHeadersGroupingInfos(ths: EsThDirective[]): {
+        leafs: EsThDirective[];
+        groupingLevel: number;
+        parentsCache: any;
+        thsCache: any;
+    };
+    /**
+     * Genera gli header groups da una lista di info sui th all'interno della variabile **TMPRowThGroups**
+     *
+     * @param {{ leafs: EsThDirective[], groupingLevel: number, parentsCache: any, thsCache: any }} infos Informazioni di raggruppamento valutate precedentemente
+     */
+    evaluateHeaderGroups(infos: {
+        leafs: EsThDirective[];
+        groupingLevel: number;
+        parentsCache: any;
+        thsCache: {
+            [index: string]: EsThDirective;
+        };
+    }): void;
+    /**
+     * Calcola il numero di salti da un header foglia all'ultimo parent della catena
+     *
+     * @param {EsThDirective} th Header da cui scorrere i padri per capire quanti livelli ci sono sopra
+     * @param {{ [index: string]: EsThDirective }} thsCache Cache degli header
+     */
+    private jumpsToFinalParent;
+    /**
+     * Metodo che genera l'ordine di default delle colonne
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     */
+    generateDefaultOrder(ths: EsThDirective[], view: AppSearch<any>): void;
+    /**
+     * Applica l'ordine specificato alle varie colonne
+     *
+     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
+     * @param {boolean} finalize Se **true** significa che non mi aspetto di dover effettuare altre operazioni e posso renderizzare la situazione in base ai RowContext
+     * Senza finalize significa che mi aspetto altre operazioni che prima o poi richiameranno questa funzione col finalize.
+     *
+     * Ad esempio, una volta selezionato ordinamento fisico/logico delle colonne so che parte un altra ricerca che mi rivalorizzerà da "writeValue", che già chiama questa funzione.
+     * Mettendo solo la chiamata da "writeValue" come "finalizzante" mi assicuro che smanattamenti a frontend non causino flickering fino a quando non servono
+     */
+    applyOrdering(view: AppSearch<any>, finalize: boolean): void;
+    /**
+  * All'interno della dialog "Ordinamento e Visibilità Colonne" mette la colonna specificata prima della colonna precedente
+  *
+  * @param {EsTableColumn} columnItem Colonna da spostare
+  */
+    sendUp(columnItem: EsTableColumn): void;
+    /**
+     * All'interno della dialog "Ordinamento e Visibilità Colonne" mette la colonna specificata dopo la colonna successiva
+     *
+     * @param {EsTableColumn} columnItem Colonna da spostare
+     */
+    sendDown(columnItem: EsTableColumn): void;
+    /**
+     * All'interno della dialog "Ordinamento e Visibilità Colonne" pinna la colonna specificata
+     *
+     * @param {EsTableColumn} columnItem Colonna da spostare
+     */
+    pinOrUnpinColumn(columnItem: EsTableColumn): void;
+    /**
+     * All'interno della dialog "Ordinamento e Visibilità Colonne" inverte le impostazioni di visibilità della colonna
+     *
+     * @param {EsTableColumn} columnItem Colonna da spostare
+     */
+    columnClicked(item: EsTableColumn): void;
+    /** All'apertura della dialog "Ordinamento e Visibilità Colonne" ricarica le informazioni attuali per permettere la modifica */
+    resetColumnVisSelection(): void;
+    /** Riaggiorna le **OrderDirectives** con le informazioni in  **ColumnsList** */
+    private refreshColumnOrdering;
+    /** Effettua la selezione o meno del check globale (**globalColVisCheck**) di visibilità in base a se tutte le **TMPColumnsList** sono visibili o no */
+    updateGlobalColVisCheck(): void;
+    /**
+     * Chiamato quando una colonna viene riordinata all'interno della lista delle visibilità/posizioni colonne
+     *
+     * @param {CdkDragDrop<EsTableColumn[]>} event Evento di drop della lista
+     */
+    columnReordered(event: CdkDragDrop<EsTableColumn[]>): void;
+    /**
+     * Chiamato quando una colonna viene riordinata all'interno della lista delle visibilità/posizioni colonne
+     *
+     * @param {number} index Indice in cui voglio droppare l'elemento draggato
+     * @param {CdkDrag<EsTableColumn>} item Oggetto che sto draggando
+     *
+     * @returns {boolean} **true** se la colonna può essere spostata sull'indice **index**, **false** altrimenti
+     */
+    sortPredicate(index: number, item: CdkDrag<EsTableColumn>): boolean;
+    /**
+     * Funzione che effettua la conferma della visibilità e dell'ordine delle colonne.
+     *
+     * Questa selezione viene inoltre salvata nelle preferenze (**@esfaenza/preferences**), qualora l'Input **SavePreferences** fosse valorizzato
+     *
+     * @returns {boolean} **true** se non ci sono problemi, **false** altrimenti
+     */
+    confirmColumnVisibilitySelection(): boolean;
+    /**
+     * Effettuo l'unpinning di una colonna in maniera programmatica semplicemente eseguendo una per una le operazioni che verrebbero eseguite altrimenti
+     *
+     * @param {string} id Codice della colonna da spinnare
+     */
+    unpinColumn(id: string): void;
+    /** Sul click nella checkbox di selezione globale si scorrono tutte le colonne e si impostano al valore della check globale */
+    globalColVisCheckChanged(): void;
+}
+
+/** Classe contenente le gestioni particolari della modalità dinamica dell'es-table */
+declare class DynamicModeHandler {
+    private est;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent);
+    /** Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna */
+    eventuallyReviewDynamicColumns(): void;
+    /** Genera partendo dalle **DynamicRowColumnsDefinition** la lista di **EsThDirective** e **EsTdDirective** che servono per la tabella */
+    emitThsAndTdsBasedOnDynamicDefinition(): {
+        ths: EsThDirective[];
+        tds: EsTdDirective[];
+    };
+    /** @ignore Helper */
+    private getThFromOperation;
+    private getTdFromOperation;
+    private getThFromColumnDef;
+    /** @ignore Helper */
+    private getTdFromColumnDef;
+}
+
+/** Classe contenente la gestione della modalità gerarchica */
+declare class HierarchyModeHandler {
+    private est;
+    /** @ignore Costruttore*/
+    constructor(est: EsTableComponent);
+    /**
+     * Data una lista di oggetti assegno il livello gerarchico rispetto alla lista di oggetti passata
+     *
+     * @param {any[]} objs Lista di oggetti a cui aggiungere l'informazione del livello gerarchico
+     */
+    assignHierarchyLevels(objs: any[]): void;
+    private orderItemsInPlace;
+    /**
+     * Per ognuno degli oggetti passati gli assegna un livello di gerarchia in base a **ParentKey** e **OwnKey**
+     *
+     * @param {any[]} objs Oggetti a cui assegnare il livello di gerarchia
+     * @param {number} levelToAssign Livello che sta assegnando attualmente questa iterazione (dato che è ricorsiva)
+     *
+     * @returns {number} Numero di oggetti a cui è stato assegnato un livello gerarchico
+     */
+    private assignLevel;
+    /**
+     * Funzione che permette di effettuare l'espansione di un parent quando la tabella funziona in modalità gerarchica
+     *
+     * @param {string} key Chiave del parent da espandere
+     */
+    expandParent(key: string): void;
+    /**
+     * Funzione che permette di effettuare il collapse di un parent quando la tabella funziona in modalità gerarchica
+     *
+     * @param {string} key Chiave del parent da collassare
+     */
+    collapseParent(key: string): void;
+    /**
+     * Collassa ricorsivamente tutti i figli di un parent identificato dalla **parentKey**
+     *
+     * @param {string} parentKey Chiave del parent di cui collassare i figli
+     */
+    private collapseChildOfParent;
+}
+
+/** Classe che si occupa della gestione del recupero degli oggetti, paginazione e tutto ciò in cui gli elementi caricati vengono manipolati direttamente */
+declare class ItemsHandler {
+    private est;
+    private utilities;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler);
+    /**
+     * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia
+     *
+     * @param {boolean} onlyselected [false] Indica di prendere solo gli oggetti selezionati
+     * @param {boolean} refreshPaging [false] Indica se aggiornare le informazioni di paginazione o meno
+     * @param {boolean} allIfPossible [false] Indica se prendere tutti gli oggetti quaora possibile, usato solo in ArrayMode
+     *
+     * @returns {any[]} Lista degli oggetti su cui effettuare il bind lato interfaccia
+     */
+    getItemsByMode(onlyselected?: boolean, refreshPaging?: boolean, allIfPossible?: boolean): any[];
+    /**
+     * Metodo per effettuare il refresh della paginazione sul cambiamento degli oggetti da visualizzare in una singola pagina.
+     *
+     * Vale solo per la modalità Array
+     *
+     * @param {number} pageSize Dimensione della pagina
+     */
+    refreshPaging(pageSize: number): void;
+    /**
+     * Ottiene gli oggetti in base alla sorgente
+     */
+    private getViewItemsBySource;
+    /** Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata */
+    private adaptViewToPaging;
+    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */
+    arrayModeReviewOrderings(items: any[]): any[];
+}
+
+/** Classe che gestisce la modalità Report dell'es-table utilizzata nel Metering */
+declare class ReportModeHandler {
+    private est;
+    private utilities;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, utilities: UtilitiesHandler);
+    /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */
+    reviewReportBindings(): void;
+    /**
+     * Data una AppSearch questo metodo genera la lista di th e td che si possono collegare al giro standard.
+     * Se non ci fosse questo passaggio intermedio la gestione della modalità report sarebbe 100% custom,
+     * come poi lo era prima che la facessi passare dal giro che fanno tutte le altre modalità
+     *
+     * @param {AppSearch<any>} view View in modalità report contenente le informazioni sulle colonne
+     *
+     * @returns {{ ths: EsThDirective[], tds: EsTdDirective[] }} Lista di direttive per gli header e per il body
+     */
+    generateThsAndTdsFromView(view: AppSearch<any>): {
+        ths: EsThDirective[];
+        tds: EsTdDirective[];
+    };
+}
+
+/** Classe che gestisce le selezioni degli oggetti */
+declare class SelectionHandler {
+    private est;
+    private rgHandler;
+    /** Cache di selezione Hash - Oggetto per la variabile **items** dell'itemSelector. Facilita le operazioni di lookup via hash*/
+    private itemsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **groups** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private groupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **exclusions** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **group_exclusions** dell'itemSelector. Facilita le operazioni di lookup via hash */
+    private group_exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **items** dell'itemSelector. Facilita le operazioni di lookup via indice*/
+    private i_itemsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **groups** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_groupsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **exclusions** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_exclusionsCache;
+    /** Cache di selezione Hash - Oggetto per la variabile **group_exclusions** dell'itemSelector. Facilita le operazioni di lookup via indice */
+    private i_group_exclusionsCache;
+    /** Ultima cella selezionata singolarmente */
+    private lastSingleSelection;
+    /** @ignore Costruttore */
+    constructor(est: EsTableComponent, rgHandler: RowGroupingHandler);
+    /** Ripulisce le cache di selezione */
+    clearSelectionCaches(): void;
+    /**
+     * Valuta quali elementi devono essere marcati come selezionati nella vista attuale. Si basa sull'oggetto **selection** interno all'AppSearch
+     *
+     * @param {any[]} items Oggetti di cui valutare la selezione
+     * @param {ItemsSelection<any>} selectionItem Oggetti di selezione derivante dalla view o dall'oggetto per Array
+     */
+    evaluateSelection(items: any[], selectionItem: ItemsSelection<any>): void;
+    /**
+     * Precompila le informazioni sullo stato di selezione tutto a false per le celle della tabella
+     *
+     * @param {any[]} items Oggetti attualmente bindati sulla tabella
+     * @param {EsThDirective[]} ths Colonne su cui gli oggetti sono bindati
+     */
+    evaluateSingleCellSelection(items: any[], ths: EsThDirective[], dyn: EsTableColumnsDefinition[]): void;
+    /** @ignore */
+    private fillSelectionStatusByDynamicColumns;
+    /** @ignore */
+    private fillSelectionStatusByEsThs;
+    /**
+     * Implementazione agnostica della valutazione delle selezioni degli oggetti. Richiede gli oggetti della vista attuale e l'itemSelector
+     *
+     * @param {any[]} items Oggetti di cui aggiornare lo stato di selezione
+     * @param {ItemsSelection<any>} selectionItem Oggetto contenente lo stato attuale di selezione
+     */
+    private handleSelectionEvaluation;
+    /**
+     * Dato un oggetto trova la cella di cache in cui è registrato e aggiorna il contenuto
+     *
+     * @param {any} item Oggetto da aggiornare
+     */
+    private rehidrateCache;
+    /**
+     * Dato un gruppo controlla ricorsivamente l'albero di cui fa parte se c'è stata una inclusione o esclusione diretta
+     *
+     * @param {any} grp Gruppo da controllare
+     *
+     * @returns {'none' | 'excluded' | 'included'}
+     * 'none' se non ci sono informazioni su inclusioni o esclusioni
+     * 'included' se il gruppo controllato è stato incluso in maniera esplicita dall'albero dei gruppi padri
+     * 'excluded' se il gruppo controllato è stato escluso in maniera esplicita dall'albero dei gruppi padri
+     */
+    private parentTreeStatus;
+    /**
+     * Helper per gestire la selezione di N elementi utilizzando la Cache di selezione ed eventualmente aggiornando il concetto di "all selection"
+     *
+     * Vunziona sia in modalità Array che in modalità View Semplice o View Avanzata (con le Custom Cells)
+     *
+     * @param {any[]} items Oggetti da selezionare o deselezionare
+     * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
+     * @param {boolean} globalCheck Valore del check globale
+     *
+     * @returns {ItemsSelection<any>} Oggetto di selezione aggiornato con le informazioni sull'ultima operazione effettuata
+     */
+    handleItemsSelection(items: any[], forcedVal?: boolean, globalCheck?: boolean): ItemsSelection<any>;
+    /**
+     * Dato L'oggetto di selezione, l'oggetto da selezionare/deselezionare e tutti i parametri del caso effettua le operazioni che servono.
+     *
+     * Logica semplificata rispetto all'originale **performSelectionOperations** per lavorare in una modalità in cui tutti gli elementi sono caricati (**ArrayGrouping()** = true)
+     */
+    private performSimpleSelectionOperations;
+    /**
+     * Helper per selezionare un gruppo e, ricorsivamente, se tutti i gruppi sottostanti al parent sono selezionati, selezionare i gruppi padri
+     *
+     * @param {any} group Gruppo da selezionare
+     */
+    private selectGroup;
+    /**
+     * Dato L'oggetto di selezione, l'oggetto da selezionare/deselezionare e tutti i parametri del caso effettua le operazioni che servono.
+     *
+     * La logica di questa funzione è nata essenzialmente da spam di trial & error ed è stata testata solo fino a due livelli di raggruppamento,
+     * qualsiasi cosa vada oltre non è 100% detto che funzioni...
+     */
+    private performSelectionOperations;
+    /** Helper per evitare di riscrivere ogni santa volta array.splice(array.indexof(item), 1); */
+    private removeItem;
+    /** Helper per evitare di riscrivere ogni santa volta array.push(item); e la gestione della  */
+    private addItem;
+    /**
+     * Ottiene il trittico di selezione, cioè l'array degli oggetti che si vuole manipolare e le due cache collegate ad esso
+     *
+     * @param {'group' | 'item' | 'group_exclusion' | 'exclusion'} subject Oggetto logico desiderato su cui effettuare le operazioni successive
+     * @param {ItemsSelection<any>} base Selettore di base
+     *
+     * @returns {CacheTriptic} Trittico di selezione
+     */
+    private getTriptic;
+    /**
+     * Dato un oggetto restituisce il gruppo di cui fa parte, se esiste
+     *
+     * @param {any} item Oggetto di cui trovare il gruppo
+     */
+    private getItemGroup;
+    /**
+     * Data la chiave di un gruppo restituisce tutti gli oggetti con quella chiave
+     *
+     * @param {any} group Chiave da cercare
+     * @param {'selected' | 'unselected'} status Stato degli elementi, selezionati o no
+     * @param {boolean} recursive Indica se cercare solo gli elementi direttamente collegati o se prendere anche quelli dei gruppi figli
+     *
+     * @returns {any[]} Oggetti di tipo **_item** facenti capo alla chiave **groupKey**
+     */
+    private getGroupItems;
+    /**
+     * Data la chiave di un gruppo restituisce tutti gli oggetti con quella chiave
+     *
+     * @param {any} group Gruppo di cui cercare il parent
+     *
+     * @returns {any} Oggetto di tipo **_group** rappresentante il parent del **group** attuale
+     */
+    private getGroupParent;
+    /**
+     * Data la chiave di un gruppo restituisce tutti i gruppi figli
+     *
+     * @param {string} group Gruppo che rappresenta il padre di cui cercare i figli
+     * @param {'selected' | 'unselected'} status Stato dei gruppi, selezionati o no
+     * @param {boolean} recursive Indica se cercare solo i gruppi direttamente collegati o se prendere anche quelli dei gruppi figli
+     *
+     * @returns {any[]} Oggetti di tipo **_group** facenti capo alla chiave **groupKey**
+     */
+    private getGroupChildGroups;
+    /** Finalizza le informazioni di selezione del **ItemsSelection** corrente */
+    private finalizeSelectionInformations;
+    /** Compatta una cache di indici */
+    private compactIndexMap;
+    /**
+     * Valuta la quantità di oggetti che sono stati selezionati al termine di un evento di selezione
+     *
+     * @returns {number} Numero di oggetti selezionati
+     */
+    private evaluateSelected;
+    /** Gestisce il comando di "Seleziona tutto in tutte le pagine" o il suo contrario, cioè "Reimposta selezione" */
+    selectAllOrResetSelection(): void;
+    /**
+     * @TODO Spostare in SelectionHandler
+     *
+     * Registra la selezione singola su una cella sulla combo di comandi "CTRL + Click".
+     * Se viene premuto anche il tasto Shift viene creato un range di selezione il cui status di "selezionato" viene salvato nella
+     * matrice virtuale **selectionStatus**
+     *
+     * @param {any} event Evento Javascript di Click
+     * @param {number} row Indice della riga. Non è l'indice vero e proprio ma è l'ordinale (.ordinal) dell'oggetto bindato su quella riga
+     * @param {number} column Indice della colonna preso banalmente dall'ngIf sui thElement
+     * @param {{ row: number, column: number }} firstSelectionOverride Permette di overridare il primo elemento selezionato
+     */
+    singleCellSelection(event: {
+        view: any;
+        range: boolean;
+    }, row: number, column: number, firstSelectionOverride?: {
+        row: number;
+        column: number;
+    }): void;
+    setSelectionStatusBorders(from: {
+        row: number;
+        column: number;
+    }, to: {
+        row: number;
+        column: number;
+    }): void;
+    /**
+     * Helper per ripulire lo stato di selezione delle singole celle della tabella, ad esclusione di una singola coordinata
+     *
+     * @param {{row: number, column: number}} exclusion Coordinata da escludere nella pulizia
+     */
+    clearSelectionStatusExcluding(exclusion?: {
+        row: number;
+        column: number;
+    }): void;
+    /**
+     * Helper che esamina la matrice **selectionStatus** e ne estrappola gli elementi selezionati in una comoda matrice
+     *
+     * @returns {{ value: string, type: InputType, val_setter: Function }[][]} Matrice di elementi selezionati con la loro informazione sul tipo
+     */
+    getSelectionStatusSelection(): ItemPropEditableReference[][];
+    /**
+     * Data la matrice di selezione generata dal metodo **getSelectionStatusSelection** genera la strigna vera e propria da copiare nella Clipboard
+     *
+     * @param {{ value: string, type: InputType }[][]} sel Matrice di selezione con valori e tipi dei dati selezionati
+     *
+     * @returns {string} Stringa da copiare nella clipboard, le stringhe vengono wrappate fra doppi apici e fra un valore e l'altro viene messo un tab
+     * in modo che siano compatibili anche con la copia su Excel
+     */
+    getClipbardTextFromSelection(sel: {
+        value: string;
+        type: InputType | string;
+    }[][]): string;
+    /**
+     * Ottiene la rappresentazione stringa di un valore dato un tipo
+     *
+     * @param {{ value: string, type: InputType }} valType Oggetto Valore - Tipo da cui estrapolare la rappresentazione del dato in stringa
+     *
+     * @returns {string} Valore convertito in stringa in base al tipo
+     */
+    getValueByType(valType: {
+        value: string;
+        type: InputType | string;
+    }): string;
+}
+
+/** Classe che fornisce dei metodi di estensione in grado di riconoscere e dispatchare l'evento copia e incolla lanciato su una pagina web */
+declare class CopyPasteDetector {
+    /** Dispatcher del Copia */
+    OnCopy: Subject<void>;
+    /** Dispatcher dell' Incolla */
+    OnPaste: Subject<void>;
+    /** Riferimento all'estable attiva per evitare di spammare copia incolla dove non servono */
+    ActiveEstReference: any;
+    /** @ignore */
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyPasteDetector, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CopyPasteDetector>;
+}
+
+/** Classe che fornisce dei metodi di estensione in grado di riconoscere e dispatchare l'evento copia e incolla lanciato su una pagina web */
+declare class Logger {
+    debugMode: boolean;
+    /** @ignore */
+    constructor(debugMode: boolean);
+    log(text: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Logger, [{ optional: true; }]>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Logger>;
+}
+
+/** Componente che permette di rappresentare una griglia di valori */
+declare class EsTableComponent implements ControlValueAccessor {
+    private _zone;
+    ngControl: NgControl;
+    private prefService;
+    private deafults;
+    exportGlobalAcl: string;
+    lc: LocalizationService;
+    cdr: ChangeDetectorRef;
+    private utilities_H;
+    utiExts: UtilityService;
+    private expExts;
+    dateExts: DateService;
+    private msgExts;
+    private copyPasteDetector;
+    private clipboardService;
+    private logger;
+    private emb;
+    private rendererRef;
+    private _destroyed$;
+    /** @ignore */ export_H: ExportHandler;
+    /** @ignore */ columnMetadata_H: ColumnMetadataHandler;
+    /** @ignore */ dynamicMode_H: DynamicModeHandler;
+    /** @ignore */ hierarchyMode_H: HierarchyModeHandler;
+    /** @ignore */ items_H: ItemsHandler;
+    /** @ignore */ reportMode_H: ReportModeHandler;
+    /** @ignore */ rowGrouping_H: RowGroupingHandler;
+    /** @ignore */ selection_H: SelectionHandler;
+    /** @ignore */ private copySubscription;
+    /** @ignore */ private pasteSubscription;
+    /** @ignore */
+    constructor(_zone: NgZone, ngControl: NgControl, prefService: PreferencesService, deafults: EsTableDefaultable, exportGlobalAcl: string, lc: LocalizationService, cdr: ChangeDetectorRef, utilities_H: UtilitiesHandler, utiExts: UtilityService, expExts: ExportService, dateExts: DateService, msgExts: MessageService, copyPasteDetector: CopyPasteDetector, clipboardService: ClipboardService, logger: Logger, emb: AppEmbeddingExtensions, rendererRef: Renderer2);
+    /** Subject utilizzato internamente lato EsTable per causare il Focus lato componente di Input */
+    FocusSubject: Subject<void>;
+    /** Timer che verrà impostato a **doubleClickBufferMs** per capire se è stato effettuato un click singolo o un doubleclick */
+    private cellDbClickTimer;
+    /** Se vengono effettuati 2 click a distanza inferiore a questi Millisecondi viene considerato un doppio click */
+    private doubleClickBufferMs;
+    /** Tiene da conto l'ultimo elemento selezionato in modo da poter effettuare il SHIFT+CLICK */
+    private lastSelected;
+    /** View finale su cui bindarsi lato Frontend, il tipo può essere IAppSearch<any> (per la **viewMode**), any[] (per l'**arrayMode**) */
+    View: any;
+    /** Modello da cui l'es-table mostra i pulsanti di paginazione in basso a destra */
+    arrayPulsanti: WritableSignal<{
+        val: number;
+        cssClass: string;
+    }[]>;
+    /** Indica se l'es-table deve mostrare il check globale nell'header per fare il "seleziona tutto" */
+    globalCheck: _angular_core.ModelSignal<boolean>;
+    /** Conteggio interno per il numero di elementi selezionati */
+    selectedObjects: WritableSignal<number>;
+    /** Indica se è possibile effettuare una selezione massiva */
+    canSelectAll: WritableSignal<boolean>;
+    /** Indica se il componente sta gestendo un IAppSearch<any> */
+    viewMode: WritableSignal<boolean>;
+    /** Indica se il componente sta gestendo un any[] */
+    arrayMode: WritableSignal<boolean>;
+    /**
+     * Contenitore degli elementi da listare lato interfaccia dopo tutte le elaborazioni del caso,
+     * generalmente non sono altro che tutti gli oggetti da presentare con in più l'hash calcolato per identificare 1 oggetto con la propria riga
+     */
+    boundSource: WritableSignal<any[]>;
+    /** Stessa cosa della **boundSource**, utilizzata come appoggio temporaneo interno */
+    TMPBoundSource: any[];
+    /** @deprecated "Fetta" di oggetti utilizzata nell'endless scroll, ogni elemento di questo array è un blocchetto di 100 elementi */
+    boundSubSources: any[];
+    /** @deprecated Questa funge da indicatore per gli slice inseriti, la lunghezza dovrebbe essere corrispondente a **boundSubSources** */
+    addedSlices: number[];
+    /** Variabile che identifica il valore del "seleziona Tutto" nella paginazione */
+    defaultAllPageOverride: number;
+    /** Serve per tenere in memoria il conteggio precedente e recuperarlo in caso diventi -2 (verificare con Ale perché la logica del -2) */
+    previousCount: number;
+    /** Indica se utilizzare il sistema di autoupdate, cioè un trigger time-izzato in alto a destra della tabella che ripete le ricerche ogni X **seconds** */
+    autoUpdate: _angular_core.ModelSignal<boolean>;
+    /** Numero di secondi da fare trascorrere fra una ricerca e l'altra */
+    seconds: _angular_core.ModelSignal<string>;
+    /** Riferimento all'Interval che viene generato se **autoUpdate** è impostata a true in modo da poterlo ripulire */
+    updateTimer: any;
+    /** Impostata a true ogni volta che viene avviata una ricerca, e a false ogni volta che un nuovo valore viene ricevuto */
+    researchInProgress: _angular_core.ModelSignal<boolean>;
+    /** Modello di appoggio temporaneo per i **RowTDs** */
+    TMPRowTDs: {
+        [context: string]: WritableSignal<TdElement>[];
+    };
+    /** Modello rappresentante un dizionario di righe della tabella, con chiave l'hash e valore la lista di celle */
+    RowTDs: {
+        [context: string]: WritableSignal<TdElement>[];
+    };
+    /** Indica se **RowTDs** è un oggetto vuoto o meno */
+    EmptyRowTds: WritableSignal<boolean>;
+    /** Modello di appoggio temporaneo per i **RowTHs** */
+    TMPRowTHs: ThElement[];
+    /** Modello rappresentante un singolo th della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
+    RowTHs: ThElement[];
+    /** Modello di appoggio temporaneo per i **RowThGroups** */
+    TMPRowThGroups: ThGroup[][];
+    /** Modello rappresentante un singolo header group della tabella. Questa lista è già ordinata e pronta per essere utilizzata in ngFor */
+    RowThGroups: ThGroup[][];
+    /**
+     * Lista dei contesti. Un contesto non è altro che un hash particolare calcolato su un oggetto che identifica univocamente tale oggetto.
+     *
+     * Ognuno di questi contesti rappresenterà a sua volta, univocamente, una riga all'interno della tabella
+     */
+    RowContexts: any[];
+    /** Direttive di ordinamento delle colonne (non ordinamento dei dati ma delle colonne in se) */
+    OrderDirectives: string[];
+    /** Codice dell'ultimo oggetto solezionato */
+    lastSelectedItemID: any;
+    /**
+     * Decide se utilizzare o meno le CustomCells. Impostandolo a **true** l'es-table diventa in grado di gestire nativamente:
+     *
+     * 1) Ordinamento e visibilità delle colonne
+     *
+     * 2) Ordinamento dei dati
+     *
+     * 3) Modalità Gerarchica
+     *
+     * ecc...
+     * viene dedotto dal sistema in automatico
+     */
+    UseCustomCells: WritableSignal<boolean>;
+    /**
+     * Indica se oltre alle colonne dinamiche specifiche di un tipo di oggetto ci sono anche colonne dinamiche aggiunte dall'utente
+     *
+     * Es. una colonna in cui mostrare sempre un iconcina
+     */
+    UserDefinedDynamicCols: WritableSignal<boolean>;
+    /** Indica che questo è il primo Bind della tabella, viene settato a false non appena il primo bind viene terminato con successo */
+    FirstBind: WritableSignal<boolean>;
+    /** Lista di colonne che si possono visualizzare/ordinare fra di loro */
+    ColumnsList: EsTableColumn[];
+    /** Variabile d'appoggio usata dalla dialog di selezione/nascondimento, per evitare di danneggiare **ColumnsList** in caso di modifiche poi annullate */
+    TMPColumnsList: EsTableColumn[];
+    /** Valore del check globale di visibilità valido per tutte le colonne in **ColumnsList** */
+    globalColVisCheck: _angular_core.ModelSignal<boolean>;
+    private setUnderlyingSignal;
+    /** Query per recuperare tutte le direttive per gli editor custom delle celle */
+    EsTdEditorDirectives: QueryList<EsTdEditorDirective>;
+    /** Query per recuperare tutte le nuove direttive  assegnati a direttiva (Per la modalità dinamica dell'es-table) */
+    EsTdsDirective: QueryList<EsTdDirective>;
+    /** Query per recuperare tutti gli es-td assegnati a direttiva (Per la modalità dinamica dell'es-table) */
+    EsThsDirective: QueryList<EsThDirective>;
+    /** Query per recuperare tutti gli es-td e gli es-th assegnati da parte di un provider (per integrare in maniera dinamica i th e td esistenti) */
+    ThTdProvider: QueryList<ThTdProvider>;
+    /** Permette di collegare un provider senza passare dalla proiezione */
+    EsThTdProvider: ThTdProvider;
+    /** Query per recuperare le informazioni del body (punto della tabella dove vengono mostrate le righe) */
+    bodyRef: any;
+    /** Query per recuperare le informazioni dell'header (punto della tabella dove vengono mostrate le intestazioni delle righe) */
+    headerRef: any;
+    /** @deprecated Query per recuperare le informazioni sul raggruppamento degli header */
+    headerGroupRef: any;
+    /** @deprecated Query per recuperare le informazioni sul raggruppamento di secondo livello degli header */
+    secondaryHeaderGroupRef: any;
+    /** Query per recuperare il campo di Input attuale. Dopo un doppio click lo becco e lo focusso appena termina la change detection */
+    inputField: ElementRef;
+    /** Opzioni extra che devono apparire nel Menù contestuale in alto a destra, richiamato dai 3 pallini verticali */
+    CornerMenuOptions: _angular_core.InputSignal<CornerMenuOption[]>;
+    /** Indica se dev'essere possibile effettuare il resize delle colonne */
+    _ColumnsResizable: _angular_core.InputSignal<boolean>;
+    ColumnsResizable: WritableSignal<boolean>;
+    /** Indica se dev'essere possibile effettuare il pinning delle colonne */
+    _ColumnsPinnable: _angular_core.InputSignal<boolean>;
+    ColumnsPinnable: WritableSignal<boolean>;
+    /** Indica se dev'essere disponibile il sistema di aggiornamento automatico */
+    _AutoUpdate: _angular_core.InputSignal<boolean>;
+    AutoUpdate: WritableSignal<boolean>;
+    /** Indica l'altezza cablata che deve assumere la tabella. Es: "100px" | "100%" ...  */
+    Height: _angular_core.InputSignal<string>;
+    /** Indica il colore di sfondo dello spazio vuoto (non ricoperto da dati). Particolarmente utile da impostare in caso di **Height** diverso da null  */
+    EmptySpaceBackgroundColor: _angular_core.InputSignal<string>;
+    /** Indica se dev'essere l'estable a gestire la ricerca, anche la prima.  **/
+    EsTableHandledSearch: _angular_core.InputSignal<boolean>;
+    /** Permette di impostare l'altezza massima della tabella. Se null la dimensione si adatta al numero di elementi attualmente in visualizzazione */
+    MaxHeight: _angular_core.InputSignal<number>;
+    /** Classi da applicare al contenitore della tabella */
+    _ContainerClass: _angular_core.InputSignal<string>;
+    ContainerClass: WritableSignal<string>;
+    /** Permette o meno l'export in formato XLSX */
+    XLSXExport: _angular_core.InputSignal<boolean>;
+    /** Permette o meno l'export in formato CSV */
+    CSVExport: _angular_core.InputSignal<boolean>;
+    /** Permette di visualizzare o meno l'opzione di paginazione "Tutti" */
+    _AllSearch: _angular_core.InputSignal<boolean>;
+    AllSearch: WritableSignal<boolean>;
+    /** Diminuisce gli spazi fra una cella e l'altra, e internamente il padding del font in modo da presentare molti più dati in un'unica pagina */
+    HighCellDensity: _angular_core.InputSignal<boolean>;
+    /** Abilita o meno la possibilità di selezionare oggetti */
+    _Selection: _angular_core.InputSignal<boolean>;
+    Selection: WritableSignal<boolean>;
+    /** Mostra o meno un messaggio di Loading al primo caricamento della tabella */
+    ShowLoadingOnBootstrap: _angular_core.InputSignal<boolean>;
+    /** Se impostato a **true** aggiunge una colonna con pulsante di eliminazione per effettuare l'elimina dell'oggetto relativo */
+    Removal: _angular_core.InputSignal<boolean>;
+    /**
+     * Condizione che nasconde l'icona di eliminazione inserita impostando **Removal** a true qualora la condizione non venisse rispettata
+     *
+     * Come condizione si considera un semplice campo su cui effettuare un controllo booleano, come ad esempio "canremove"
+     */
+    RemovalCondition: _angular_core.InputSignal<string>;
+    /** Indica se abilitare la possibilità di esportare la vista dati attuale */
+    _Export: _angular_core.InputSignal<boolean>;
+    Export: WritableSignal<boolean>;
+    /** Indica se permettere la selezione multipla Windows-like cliccando un oggetto e facendo poi Shift + click su un oggetto successivo */
+    _ShiftClick: _angular_core.InputSignal<boolean>;
+    ShiftClick: WritableSignal<boolean>;
+    /** Indica il testo che va a sostituire "Oggetti Visualizzati" in caso si stia facendo qualcosa di custom */
+    CountLabel: _angular_core.InputSignal<string>;
+    /** Indica se nascondere o mostrare il componente di paginazione */
+    _HidePaging: _angular_core.InputSignal<boolean>;
+    HidePaging: WritableSignal<boolean>;
+    /** Indica se nascondere o mostrare il conteggio degli elementi trovati */
+    _HidePagingCount: _angular_core.InputSignal<boolean>;
+    HidePagingCount: WritableSignal<boolean>;
+    /** Indica se nascondere o mostrare i pulsanti di paginazione */
+    _HidePagingButtons: _angular_core.InputSignal<boolean>;
+    HidePagingButtons: WritableSignal<boolean>;
+    /** Riferimento al ContextMenu (ngx-contextmenu) associato al click destro di uno o più elementi selezionati nella tabella */
+    ContextMenu: ContextMenuComponent;
+    /** Nome dell'esportazione generata da questa tabella */
+    ExportFileName: _angular_core.InputSignal<string>;
+    /** Classe (HTML) di default della tabella */
+    _TableClass: _angular_core.InputSignal<string>;
+    TableClass: WritableSignal<string>;
+    /** Funzione da utilizzare in esportazione. Ha come parametro una callback con i dati completi da esportare (dato che di default la ricerca è paginata) */
+    ExportFunction: (callback: (data: any[], type: Type<any>) => void, format: "CSV" | "XLSX") => void;
+    /** Indica di esportare solo le colonne attualmente visibili della view */
+    ExportOnlyVisibleColumns: _angular_core.InputSignal<boolean>;
+    /** @deprecated Indica la presenza di raggruppamenti a livello di header */
+    HasHeaderGroup: _angular_core.InputSignal<boolean>;
+    /** @deprecated Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */
+    HasSecondaryHeaderGroup: _angular_core.InputSignal<boolean>;
+    /** Indica se nascondere gli Header della tabella */
+    HeaderHidden: _angular_core.InputSignal<boolean>;
+    /** Indica se nascondere il Body della tabella */
+    BodyHidden: _angular_core.InputSignal<boolean>;
+    /**
+     * Indica se la selezione è temporaneamente disabilitata. Rispetto all'Input **Selection** che visivamente gestisce se ci sono o no gli input di selezione,
+     * questo Input gestisce se questi input sono abilitati o meno
+     */
+    SelectionDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Indica se forzare il sistema di selezione a gestire un elemento per volta.
+     * Selezionare un'altra riga con una già selezionata applicherà la selezione alla nuova riga, rimuovendola dall'attuale
+     */
+    SingleSelection: _angular_core.InputSignal<boolean>;
+    /** Callback che dato un oggetto resituisce l'eventuale classe da applicare alla riga collegata all'oggetto */
+    RowClassAssigner: (item: any) => string;
+    /** Permette di ordinare i dati in maniera discendente o ascendente */
+    _OrderByColumn: _angular_core.InputSignal<boolean>;
+    OrderByColumn: WritableSignal<boolean>;
+    /** Permette di avere più direttive di ordinamento dei dati */
+    MultipleOrderingDirectives: _angular_core.InputSignal<boolean>;
+    /** Permette di nascondere le colonne in base alle selezioni effettuate dal Menù contestuale in alto a destra */
+    _HiddenColumns: _angular_core.InputSignal<boolean>;
+    HiddenColumns: WritableSignal<boolean>;
+    /** Permette di riordinare le colonne in base alle impostazioni effettuate dal Menù contestuale in alto a destra */
+    _ColumnsOrdering: _angular_core.InputSignal<boolean>;
+    ColumnsOrdering: WritableSignal<boolean>;
+    /** @deprecated Eventuale supporto alle ricerche applicate alla modalità Array */
+    SearchView: _angular_core.InputSignal<AppSearch<any>>;
+    /** Abilita o disabilita il sistema che permette di selezionare tutti gli elementi nella vista */
+    _SelectAll: _angular_core.InputSignal<boolean>;
+    SelectAll: WritableSignal<boolean>;
+    /** Simula la paginazione anche per le tabelle che funzionano in modalità Array */
+    _UseArrayModePaging: _angular_core.InputSignal<boolean>;
+    UseArrayModePaging: WritableSignal<boolean>;
+    /** Definizione di colonne dinamche per la modalità, appunto, dinamica */
+    _DynamicRowColumnsDefinition: _angular_core.InputSignal<EsTableColumnsDefinition[]>;
+    DynamicRowColumnsDefinition: WritableSignal<EsTableColumnsDefinition[]>;
+    /** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
+    DynamicOperations: _angular_core.InputSignal<EsTableOperationDefinition[]>;
+    /** Indica se visualizzare i dati in maniera gerarchica */
+    Hierarchy: _angular_core.InputSignal<boolean>;
+    /** Nome della proprietà che contiene l'ID del padre. Da utilizzare se **Hierarchy** è impostato */
+    _ParentKey: _angular_core.InputSignal<string>;
+    ParentKey: WritableSignal<string>;
+    /** Nome della proprietà che contiene l'ID dell'oggetto attuale. Da utilizzare se **Hierarchy** è impostato */
+    _OwnKey: _angular_core.InputSignal<string>;
+    OwnKey: WritableSignal<string>;
+    /** Indica se lasciare alla tabella l'onere di ordinare gli oggetto che arrivano in base a gerarchia / id */
+    _AutoSortHierarchy: _angular_core.InputSignal<boolean>;
+    AutoSortHierarchy: WritableSignal<boolean>;
+    /** Indica se partire con un albero espanso. Da utilizzare se **Hierarchy** è impostato */
+    StartsExpanded: _angular_core.InputSignal<boolean>;
+    /** Indica se effettuare il salvataggio delle preferenze di ricerca */
+    _SavePreferences: _angular_core.InputSignal<boolean>;
+    SavePreferences: WritableSignal<boolean>;
+    /** Allineamento di default per celle e headers */
+    _DefaultAlignment: _angular_core.InputSignal<"Left" | "Center" | "Right">;
+    DefaultAlignment: WritableSignal<"Left" | "Center" | "Right">;
+    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+    _PagingStyle: _angular_core.InputSignal<"top" | "bottom" | "both">;
+    PagingStyle: WritableSignal<"top" | "bottom" | "both">;
+    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+    _RowGroupingPagingStyle: _angular_core.InputSignal<"left" | "right">;
+    RowGroupingPagingStyle: WritableSignal<"left" | "right">;
+    /** Qualora per qualsiasi motivo non venisse usato **items** dell'AppSearch questo Input indica qual è il nome della proprietà da utilizzare */
+    ItemSourceProperty: _angular_core.InputSignal<string>;
+    /** Indica se utilizzare la cache di selezione che permette di mantenere gli stati di selezione dei vari oggetti navigando da una pagina all'altra */
+    _UseSelectionCache: _angular_core.InputSignal<boolean>;
+    UseSelectionCache: WritableSignal<boolean>;
+    /** Permette di decidere se, in modalità raggruppamento, mostrare o meno il valore delle colonne di gruppo negli oggetti finali. Di default sono nascosti */
+    _ShowItemGroupsColumns: _angular_core.InputSignal<boolean>;
+    ShowItemGroupsColumns: WritableSignal<boolean>;
+    /** Indica che tutti i campi che definiscono le modalità di modifica campo possono essere modificati in base alle impostazioni */
+    Editable: _angular_core.InputSignal<boolean>;
+    /** Indica se è possibile effettuare selezioni a range per poi farci eventualmente copia incolla */
+    RangeSelection: _angular_core.InputSignal<boolean>;
+    /** Indica il numero di millisecondi per cui debouncare il writeValue per la modalità **EsTableHandledSearch** */
+    SearchThrottle: _angular_core.InputSignal<number>;
+    /** Evento che viene richiamato al cambio di oridnamento di una colonna */
+    onOrderChanged: EventEmitter<AppOrdering>;
+    /**
+     * Evento che viene richiamato quando l'es-table ritiene sia necessario ri-effettuare la ricerca.
+     * Il booleano dell'evento indica se viene suggerito di resettare la pagina o meno.
+     *
+     * Solo in caso venga utilizzata la modalità a raggruppamenti di righe può succedere che l'es-table passi un intero AppSearch come parametro di ricerca,
+     * in quel caso l'applicazione ricevente dovrà onorare la richiesta spedendo al backand l'oggetto di ricerca AS-IS
+     *
+     * il tipo dell'Emitter invece di essere [boolean | AppSearch<any>] è stato impostato a "any" per evitare problemi di retrocompatibilità
+     */
+    onSearchRequest: EventEmitter<any>;
+    /** Evento che parte ad ogni modifica di "checkaggio" in forma di comodo array. Espone l'oggetto con lo stato di check attuale */
+    onSelectionChanged: EventEmitter<ItemsSelection<any>>;
+    /** Evento richiamato all'eliminazione di un oggetto */
+    onRemoval: EventEmitter<any>;
+    /** Evento richiamato all'annullamento di un'eliminazione */
+    onAbortRemoval: EventEmitter<any>;
+    /** Evento richiamato alla modifica dei modelli bindati */
+    onModelChange: EventEmitter<EsTableModelChange[]>;
+    /** Evento richiamato all'apertura del menù contestuale */
+    onOpenContextMenu: EventEmitter<void>;
+    /** Evento richiamato quando si clicca su un opzione definita nelle **CornerMenuOptions** */
+    onCornerAction: EventEmitter<{
+        id: string;
+        estable: any;
+    }>;
+    /** Evento richiamato quando si clicca su un opzione definita nelle **DynamicOperations** */
+    onDynamicOperation: EventEmitter<{
+        id: string;
+        item: any;
+    }>;
+    /** Elemento HTML da cliccare per l'esportazione */
+    exportDownloader: ElementRef;
+    /** Placeholder di menù contestuale per quando non ci sono opzioni nel placeholder "Vero"  */
+    tableEmptyMenu: ContextMenuComponent;
+    /** Subscription sull'apertura del context menu da ripulire al destroy della classe */
+    private ctxMenuSubscription;
+    /** Pagina in visualizzazione (durante la paginazione in modalità Array) */
+    arraymodePage: number;
+    /** Numero di pagine (durante la paginazione in modalità Array) */
+    arraymodePages: number;
+    /** Oggetti per ogni pagina (durante la paginazione in modalità Array) */
+    _ArraymodeItemsPerPage: _angular_core.InputSignal<number>;
+    ArraymodeItemsPerPage: WritableSignal<number>;
+    /** Oggetto di selezione per la modalità Array, che deve comportarsi come la controparte in modalità View */
+    arraymodeSelection: ItemsSelection<any>;
+    /** Colonne da visualizzare in modalità array */
+    arrayColumns: string[];
+    /** Ordine delle colonne da visualizzare in modalità array */
+    arrayColumnOrdering: string[];
+    /** Ordinamenti ASC-DESC sulle colonne in modalità array */
+    arrayOrders: AppOrdering[];
+    /**
+     * Variabile che serve a gestire il momento in cui l'es-table aggiorna la paginazione (pulsanti ecc).
+     * Essendo operazioni comunque costose le effettuo solo su binding esterni, non su rewrite generati internamente
+     */
+    private internalWriteCall;
+    /**
+     * Cache che conterrà tutte le ricerche effettuate su gruppi diversi dal primo e su elementi contenuti nei gruppi.
+     * In caso di cambi di ordinamento delle colonne diverse dalla prima tutte le chiamate fatte dal secondo livello in poi devono essere rieseguite secondo la seguente logica:
+     *
+     *
+     * **Cambio ordinamento sul primo gruppo**: reload completo, non mi occupo di ripulire gli elementi bindati in alcun modo
+     *
+     * **Cambio ordinamento sulla colonna relativa all'N-esimo gruppo**: reload completo del contenuto dei gruppi precedenti, ripulendo precedentemente
+     * tutti gli elementi con **_grouplevel** = N
+     *
+     * **Cambio ordinamento su una colonna non raggruppata**: reload completo per tutti i gruppi finali aperti, devo precedentemente ripulire tutti gli elementi con **_item** = true
+     *
+     * Altri eventi non dovrebbero rappresentare problemi:
+     * - Selezione: non cambia nulla
+     * - Paginazione: cambia a livello root quindi viene ricaricato tutto comunque, stesso vale per le paginazioni interne
+     */
+    groupSearchRequestsCache: {
+        path: string;
+        route: GroupRouteFragment[];
+        view: AppSearch<any>;
+        group_column: string;
+    }[];
+    /** Variabile d'appoggio per capire se c'è bisogno di ri-effettuare una ricerca o meno */
+    private ResearchNeeded;
+    /** Colonne visibili della vista attuale. Valorizzato di default al numero massimo di colonne supportate dalla tabella per le casistiche in assenza di custom cells */
+    Columns: WritableSignal<{
+        Visibile: number;
+        VisibleUnpinned: number;
+        Global: number;
+    }>;
+    /** In caso di Row Grouping qui viene salvata la vista principale dei gruppi base */
+    MainGroupView: AppSearch<any>;
+    /** Conteggio base degli oggetti. In modalità normale viene resettato ad ogni nuova View inserita, in modalità RowGrouping viene resettato solo ad una nuova View di livello "0" */
+    BaseItemsCount: any;
+    /** Indica se ci sono delle colonne pinnate e visibili. Serve per poter settare tutte le colonne prima che arrivino dati a pinned*/
+    HasPinnedColumns: WritableSignal<boolean>;
+    /** Larghezza calcolata del container delle colonne pinnate */
+    PinnedContainerWidth: WritableSignal<number>;
+    /** Indica se nonostante siamo in modalità array sono stati individuati dei gruppi. In tal caso es-table si comporta da pseudo backend ed effettua le aggregazioni e raggruppamenti completamente lato client */
+    ArrayGrouping: WritableSignal<boolean>;
+    /** Indica che l'es-table è basata sulle direttive (nuova modalità) */
+    DirectivesBased: WritableSignal<boolean>;
+    /** Indica lo stato di selezione per singola cella */
+    selectionStatus: {
+        [index: number]: {
+            [index: number]: ItemPropEditableReference;
+        };
+    };
+    /** Chiamata reale al writeValue dopo il passaggio di **SearchThrottle** millisecondi. Solo modalità EsTableHandledSearch */
+    private callTimeout;
+    /** Cache dei th piuttosto che ricalcolarseli di continuo */
+    private thsCache;
+    /** Indica quando la cache dei th è stata fillata almeno la prima volta */
+    private thsCacheSet;
+    /** Variabili da fillare nell'After Content Init poi da riutilizzare nell'internal post bound source */
+    private EsTds;
+    private EsThs;
+    /**
+     * Flag che, se **true**, per un giro di binding mantiene la visibilità impostata localmente, piuttosto che allineare alla View bindata.
+     * Usata per modificare in maniera programmatica la visibilità delle colonne dal metodo **setHeaderVisibility**,
+     *
+     * Disclaimer: **NON MODIFICARE**
+     **/
+    useLocalVisibility: boolean;
+    /** Opzioni di paginazione */
+    PagerOptions: PagerInfos;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngAfterViewInit(): Promise<void>;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    registerOnChange(fn: any): void;
+    /** @ignore */
+    registerOnTouched(fn: any): void;
+    /** @ignore */
+    propagateChange: (_: any) => void;
+    /** @ignore */
+    changed(clearItems?: boolean): void;
+    /** @ignore */
+    writeValue(obj: any, throttle?: boolean): Promise<void>;
+    /** Funzione di trackby per il body che dovrebbe evitare il 90% delle change detection */
+    bodyTrackBy: (_: number, item: any) => any;
+    /** Funzione di trackby generica per tutti gli oggetti che hanno il campo id */
+    idTrackBy: (_: number, item: any) => any;
+    /** Funzione di trackby generica per tutti gli oggetti che hanno il campo PropertyName */
+    PropertyNameTrackBy: (_: number, item: any) => any;
+    /** Funzione di trackby generica per tutti gli oggetti che hanno il campo ID */
+    IDTrackBy: (_: number, item: any) => any;
+    /** Funzione di trackby generica per tutti gli oggetti che hanno il campo ID e Order significativi */
+    IDAndOrderTrackBy: (_: number, item: any) => string;
+    /** Funzione di trackby generica per tutti gli oggetti che hanno il campo ID */
+    valTrackBy: (_: number, item: any) => any;
+    /**
+     * Successivamente al bind del nuovo input questa funzione si occupa di finalizzare tutti i parametri di funzionamento dell'es-table
+     * in base a Input - Modello, e qualsiasi altra cosa possa servire
+     */
+    private finalizeContext;
+    /** Genera le informzioni di paginazione per la vista globale dell'es-table */
+    private setupPagingInformations;
+    /**
+     * Metodo lanciato dopo che la sorgente dati è stata correttamente bindata, si occupa di ricalcolare tutto ciò che serve
+     * all'es-table per renderizzare i valori da mostrare
+     */
+    private postBoundSourceCalculation;
+    /** Per poter distinguere le chiamate a questo metodo: Dopo il setTimeout se uso gli EsTd/EsTh vecchi, senza il setTimeout se uso le nuove direttive */
+    private internalPostBoundSource;
+    /**
+     * Effettua il binding degli oggetti pervenuti da questa chiamata con gli oggetti effettivamente da graficare
+     *
+     * @param {any} view View da cui sono arrivati gli oggetti. Può essere o un array se sono in **arrayMode** o una AppSearch<T> se sono in **viewMode**
+     */
+    private bindDisplayToLoadedItemsOrGroups;
+    /** Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML */
+    private MoveTemporaryVariablesToRealOnes;
+    /**
+     * Metodo per capire se un oggetto è completamente vuoto
+     *
+     * @param {any} obj Oggetto da controllare
+     *
+     * @returns {boolean} **true** se l'oggetto è vuoto, **false** altrimenti
+     */
+    isEmpty(obj: any): boolean;
+    /**
+     * Permette di selezionare o deselezionare in maniera arbitraria degli oggetti
+     *
+     * @param {any[]} items Oggetti da selezionare o deselezionare
+     * @param {boolean} select **true** per selezionarli, **false** per non toccarli
+     */
+    setSelectionStatus(items: any[], all: boolean, select: boolean, emit?: boolean): void;
+    /**
+     * Effettua un hard reset della selezione
+     */
+    resetSelection(emit?: boolean): void;
+    /**
+     * Metodo che gestisce il cambio di Ordinamento di una colonna
+     *
+     * @param {string} id ID della colonna il cui oridnamento è cambiato
+     * @param {'DESC' | 'ASC'} order Nuovo ordine selezionato per la colonna
+     */
+    thOrderChanged(id: string, order?: 'DESC' | 'ASC'): void;
+    /**
+     * Metodo da chiamare ogni volta che si vuole dare evidenza all'esterno del bisogno di rieffettuare la ricerca
+     *
+     * @param {boolean} resetsPage Indica al listener che deve resettare il numero di pagina
+     * @param {AppSearch<any>} viewOverride Override della view da emettere per questa ricerca
+     */
+    emitSearchRequest(resetsPage: boolean, viewOverride?: AppSearch<any>): void;
+    /**
+     * Partendo dagli **EsTds** bindati genera, all'interno del dizionario **TMPRowTDs** tutti i contesti dei vari oggetti.
+     *
+     * Vengono esclusi i TD "Interni" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte
+     *
+     * Costo: 2 scan EsThs, 1 scan EsTds
+     *
+     * @param {EsThDirective[]} ths Colonne della tabella
+     * @param {EsTdDirective[]} tds Celle della tabella
+     */
+    private evaluateRowTds;
+    /**
+     * Partendo dagli **EsThs** bindati genera, all'interno del dizionario **TMPRowTHs** tutti i contesti dei vari oggetti.
+     *
+     * Vengono esclusi i TH "Interni" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte
+     *
+     * Costo: 1 scan EsThs + 1 scan ColumnsList
+     *
+     * @param {EsThDirective[]} ths Colonne della tabella
+     */
+    private evaluateRowThs;
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indietro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    addToPageGroup(page: number, pager: GroupPager): void;
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    goToPageGroup(page: number, pager: GroupPager): void;
+    /**
+     * @TODO Spostare in SelectionHandler
+     *
+     * Gestisce i click sulla tabella solo per le righe a gruppo.
+     * O rimuove gli elementi attualmente presenti o carica il contenuto del gruppo
+     *
+     * @param {any} group Gruppo bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleGroupClick(group: Group): boolean;
+    /**
+     * Gestisce la selezione globale degli oggetti, sia per pagina che a livello di **SelectAll**
+     *
+     * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
+     */
+    globalCheckChanged(forcedVal?: boolean): void;
+    /**
+     * @TODO Spostare in SelectionHandler
+     *
+     * Gestisce i click sulla tabella, gestendo eventualmente anche gli Shift + Click per selezionare un range di oggetti
+     *
+     * @param {any} event Evento nativo HTML del click
+     * @param {any} item Oggetto bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleClick(event: any, item: any): boolean;
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indeitro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     */
+    addToPage(page: number): void;
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     */
+    goToPage(page: number): void;
+    /**
+     * Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest**
+     * per comunicare al componente che utilizza questa tabella che i dati sono da aggiornare
+     */
+    onItemsPerPageChanged(newIpp: any): void;
+    /** Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest** con la vista del separatore */
+    onGroupItemsPerPageChanged(pager: GroupPager, newIpp: number): void;
+    /** Metodo che gestisce la modifica del tempo specificato per l'aggiornamento automatico */
+    autoUpdateChanged(): void;
+    /**
+     * Metodo chiamato dal click su una delle colonne generate dall'Input **DynamicOperations**
+     *
+     * @param {any} item L'oggetto su cui va effettuata l'operazione
+     * @param {string} opid Codice identificativo dell'operazione da effettuarsi
+     */
+    dynamicOperation(item: any, opid: string): void;
+    /**
+     * Ottiene il contenuto dell'EsTd da utilizzare per la colonna specificata
+     *
+     * @param {string} column Colonna per cui cercare la cella
+     * @param {string} name Nome diretto per cercare il TD con l'ID. Questa variabile ha priorità rispetto a **column**
+     *
+     * @returns {TemplateRef<any>} Template da usare per la colonna
+     */
+    findEsTd(column: string, name?: string): TemplateRef<any>;
+    /**
+     * Ottiene il contenuto dell'editor EsTd da utilizzare per la colonna specificata
+     *
+     * @param {string} column Colonna per cui cercare l'editor
+     * @param {string} name Nome diretto per cercare l'Editor con l'ID. Questa variabile ha priorità rispetto a **column**
+     *
+     * @returns {TemplateRef<any>} Template da usare per la colonna
+     */
+    findEditor(column: string, name?: string): TemplateRef<any>;
+    /**
+     * Equivalente del metodo **addToPage** riadattato per la modalità array
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     */
+    arrayAddToPage(page: number): void;
+    /**
+     * Equivalente del metodo **goToPage** riadattato per la modalità array
+     *
+     * @param {number} page Pagina a cui navigare
+     */
+    arrayGoToPage(page: number): void;
+    /**
+     * Gestione dei click sulle opzioni del menù contestuale in alto a destra generato dall'Input **CornerMenuOptions**
+     *
+     * @param {string} cornerid Codice dell'operazione selezionata
+     */
+    cornerActionClicked(cornerid: string): void;
+    /**
+     * Impostazione modalità dell'EsTable
+     *
+     * @param {'array' | 'view' | 'report'} mode Modalità da impostare
+     **/
+    private setMode;
+    /**
+     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**,
+     * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
+     */
+    internalWriteValue(): Promise<void>;
+    /** Metodo eventualmente richiamabile anche dal componente esterno che permette di forzare un refresh della tabella */
+    forceRefresh(relaunchSearch?: boolean): void;
+    /**
+     * Imposta la visibilità di un header e di eventuali header collegati se questo header è un gruppo, dopodiché aggiorna l'es-table
+     *
+     * @param {string} groupOrHeader Header di cui settare la visibilità
+     * @param {boolean} visibility Visibilità da impostare
+     **/
+    setHeaderVisibility(groupOrHeader: string, visibility: boolean, refresh?: boolean, relaunchSearch?: boolean): void;
+    /**
+     * Funzione che in base ai click su una cella capisce se sto effettuando un'operazione di selezione o se sto entrando nell'edit di una cella con un doppio click
+     *
+     * @param {any} $event Evento nativo javascript
+     * @param {TdElement} rowItem Riferimento a binder della riga
+     * @param {any} item Item che rappresenta il contesto su cui è stato effettuato un click
+     */
+    dbClickEditOrSingleClickRowSelection($event: MouseEvent, rowItem: WritableSignal<TdElement>, item: any): void;
+    /** Evento che gestisce il comando "Copia" buttando i valori selezionati nella clipboard in base al loro tipo */
+    private handleCopy;
+    /** Evento che gestisce il comando "Incolla" prendendo i dati della clipboard e applicandoli al range di selezione attuale in base al tipo delle celle sotto */
+    handlePaste(): void;
+    /** Ripulisce il timer utilizzato per capire se è stato effettuato un doppio click o meno */
+    private clearCellClickTimer;
+    /**
+     * Handler click singolo su una riga
+     *
+     * @param {any} $event Evento nativo javascript
+     * @param {any} item Item che rappresenta il contesto su cui è stato effettuato un click
+     * @param {boolean} selection Indica se la selezione è attiva
+     * @param {boolean} internalCall Indica se la chiamata a questa funzione è interna: permette di skippare i check sulle CustomCells
+     */
+    handleRowClick($event: any, item: any, selection: boolean, internalCall?: boolean): boolean;
+    /**
+     * Gestione del click destro sull'es-table
+     */
+    onRightClick(): void;
+    /**
+     * La modifica dell'utente è iniziata. Si imposta la variabile relativa a "true" in modo da mostrare l'input di testo
+     *
+     * Dopo che l'input è apparso, dopo un ciclo di Change Detection viene attivato il Subject collegato all'input che servirà a effettuare il focus
+     *
+     * @param {TdElement} rowItem Elemento di riga su cui è stata attivata la modifica
+     * @param {any} item Oggetto sopra il quale è stata attivata la modifica
+     */
+    setupUserEdit(rowItem: WritableSignal<TdElement>, item: any): void;
+    /**
+     * La modifica dell'utente è terminata. Si reimposta la variabile relativa a "false" in modo da nascondere l'input di testo e si emette la modifica del valore
+     *
+     * @param {TdElement} rowItem Elemento di riga su cui è stata attivata la modifica
+     * @param {any} item Oggetto sopra il quale è stata attivata la modifica
+     * @param {number} columnIndex Indice della colonna su cui è avvenuta la modifica
+     */
+    finalizeUserEdit(rowItem: WritableSignal<TdElement>, item: any, columnIndex: number): void;
+    private mouseIsDown;
+    private rangeSelected;
+    private rangeStartWasIgnored;
+    private firstCoordinates;
+    mousedown(event: MouseEvent, rowItem: any, _: any): void;
+    mouseenter(event: MouseEvent): void;
+    mouseup(event: MouseEvent): void;
+    private EsTdsCache;
+    getCellReference(object: any, column: string): EsTd;
+    registerCell(event: EsTdReference, rowItem: any, _: any, cellRef: ElementRef<HTMLTableCellElement>): void;
+    showDialog(dlg: ModalDirective, elementRef: ElementRef): void;
+    private retries;
+    doFixDialog(dlg: ModalDirective, elementRef: ElementRef): void;
+    doFixBody(elementRef: ElementRef): void;
+    hideDialog(dlg: ModalDirective): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTableComponent, [null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null, null, null, null, null, null, null, null, null, null]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EsTableComponent, "es-table", never, { "globalCheck": { "alias": "globalCheck"; "required": false; "isSignal": true; }; "autoUpdate": { "alias": "autoUpdate"; "required": false; "isSignal": true; }; "seconds": { "alias": "seconds"; "required": false; "isSignal": true; }; "researchInProgress": { "alias": "researchInProgress"; "required": false; "isSignal": true; }; "globalColVisCheck": { "alias": "globalColVisCheck"; "required": false; "isSignal": true; }; "EsThTdProvider": { "alias": "EsThTdProvider"; "required": false; }; "CornerMenuOptions": { "alias": "CornerMenuOptions"; "required": false; "isSignal": true; }; "_ColumnsResizable": { "alias": "ColumnsResizable"; "required": false; "isSignal": true; }; "_ColumnsPinnable": { "alias": "ColumnsPinnable"; "required": false; "isSignal": true; }; "_AutoUpdate": { "alias": "AutoUpdate"; "required": false; "isSignal": true; }; "Height": { "alias": "Height"; "required": false; "isSignal": true; }; "EmptySpaceBackgroundColor": { "alias": "EmptySpaceBackgroundColor"; "required": false; "isSignal": true; }; "EsTableHandledSearch": { "alias": "EsTableHandledSearch"; "required": false; "isSignal": true; }; "MaxHeight": { "alias": "MaxHeight"; "required": false; "isSignal": true; }; "_ContainerClass": { "alias": "ContainerClass"; "required": false; "isSignal": true; }; "XLSXExport": { "alias": "XLSXExport"; "required": false; "isSignal": true; }; "CSVExport": { "alias": "CSVExport"; "required": false; "isSignal": true; }; "_AllSearch": { "alias": "AllSearch"; "required": false; "isSignal": true; }; "HighCellDensity": { "alias": "HighCellDensity"; "required": false; "isSignal": true; }; "_Selection": { "alias": "Selection"; "required": false; "isSignal": true; }; "ShowLoadingOnBootstrap": { "alias": "ShowLoadingOnBootstrap"; "required": false; "isSignal": true; }; "Removal": { "alias": "Removal"; "required": false; "isSignal": true; }; "RemovalCondition": { "alias": "RemovalCondition"; "required": false; "isSignal": true; }; "_Export": { "alias": "Export"; "required": false; "isSignal": true; }; "_ShiftClick": { "alias": "ShiftClick"; "required": false; "isSignal": true; }; "CountLabel": { "alias": "CountLabel"; "required": false; "isSignal": true; }; "_HidePaging": { "alias": "HidePaging"; "required": false; "isSignal": true; }; "_HidePagingCount": { "alias": "HidePagingCount"; "required": false; "isSignal": true; }; "_HidePagingButtons": { "alias": "HidePagingButtons"; "required": false; "isSignal": true; }; "ContextMenu": { "alias": "ContextMenu"; "required": false; }; "ExportFileName": { "alias": "ExportFileName"; "required": false; "isSignal": true; }; "_TableClass": { "alias": "TableClass"; "required": false; "isSignal": true; }; "ExportFunction": { "alias": "ExportFunction"; "required": false; }; "ExportOnlyVisibleColumns": { "alias": "ExportOnlyVisibleColumns"; "required": false; "isSignal": true; }; "HasHeaderGroup": { "alias": "HasHeaderGroup"; "required": false; "isSignal": true; }; "HasSecondaryHeaderGroup": { "alias": "HasSecondaryHeaderGroup"; "required": false; "isSignal": true; }; "HeaderHidden": { "alias": "HeaderHidden"; "required": false; "isSignal": true; }; "BodyHidden": { "alias": "BodyHidden"; "required": false; "isSignal": true; }; "SelectionDisabled": { "alias": "SelectionDisabled"; "required": false; "isSignal": true; }; "SingleSelection": { "alias": "SingleSelection"; "required": false; "isSignal": true; }; "RowClassAssigner": { "alias": "RowClassAssigner"; "required": false; }; "_OrderByColumn": { "alias": "OrderByColumn"; "required": false; "isSignal": true; }; "MultipleOrderingDirectives": { "alias": "MultipleOrderingDirectives"; "required": false; "isSignal": true; }; "_HiddenColumns": { "alias": "HiddenColumns"; "required": false; "isSignal": true; }; "_ColumnsOrdering": { "alias": "ColumnsOrdering"; "required": false; "isSignal": true; }; "SearchView": { "alias": "SearchView"; "required": false; "isSignal": true; }; "_SelectAll": { "alias": "SelectAll"; "required": false; "isSignal": true; }; "_UseArrayModePaging": { "alias": "UseArrayModePaging"; "required": false; "isSignal": true; }; "_DynamicRowColumnsDefinition": { "alias": "DynamicRowColumnsDefinition"; "required": false; "isSignal": true; }; "DynamicOperations": { "alias": "DynamicOperations"; "required": false; "isSignal": true; }; "Hierarchy": { "alias": "Hierarchy"; "required": false; "isSignal": true; }; "_ParentKey": { "alias": "ParentKey"; "required": false; "isSignal": true; }; "_OwnKey": { "alias": "OwnKey"; "required": false; "isSignal": true; }; "_AutoSortHierarchy": { "alias": "AutoSortHierarchy"; "required": false; "isSignal": true; }; "StartsExpanded": { "alias": "StartsExpanded"; "required": false; "isSignal": true; }; "_SavePreferences": { "alias": "SavePreferences"; "required": false; "isSignal": true; }; "_DefaultAlignment": { "alias": "DefaultAlignment"; "required": false; "isSignal": true; }; "_PagingStyle": { "alias": "PagingStyle"; "required": false; "isSignal": true; }; "_RowGroupingPagingStyle": { "alias": "RowGroupingPagingStyle"; "required": false; "isSignal": true; }; "ItemSourceProperty": { "alias": "ItemSourceProperty"; "required": false; "isSignal": true; }; "_UseSelectionCache": { "alias": "UseSelectionCache"; "required": false; "isSignal": true; }; "_ShowItemGroupsColumns": { "alias": "ShowItemGroupsColumns"; "required": false; "isSignal": true; }; "Editable": { "alias": "Editable"; "required": false; "isSignal": true; }; "RangeSelection": { "alias": "RangeSelection"; "required": false; "isSignal": true; }; "SearchThrottle": { "alias": "SearchThrottle"; "required": false; "isSignal": true; }; "_ArraymodeItemsPerPage": { "alias": "ArraymodeItemsPerPage"; "required": false; "isSignal": true; }; }, { "globalCheck": "globalCheckChange"; "autoUpdate": "autoUpdateChange"; "seconds": "secondsChange"; "researchInProgress": "researchInProgressChange"; "globalColVisCheck": "globalColVisCheckChange"; "onOrderChanged": "onOrderChanged"; "onSearchRequest": "onSearchRequest"; "onSelectionChanged": "onSelectionChanged"; "onRemoval": "onRemoval"; "onAbortRemoval": "onAbortRemoval"; "onModelChange": "onModelChange"; "onOpenContextMenu": "onOpenContextMenu"; "onCornerAction": "onCornerAction"; "onDynamicOperation": "onDynamicOperation"; }, ["bodyRef", "headerRef", "headerGroupRef", "secondaryHeaderGroupRef", "EsTdEditorDirectives", "EsTdsDirective", "EsThsDirective", "ThTdProvider"], never, false, never>;
+}
+declare class EsTdReference {
+    id: string;
+    hash: string;
+    self: EsTd;
+}
+
+/** Modello di configurazione per L'EsTable */
+declare class EsTableModuleConfig {
+    /** Indica se scrivere messaggi di log a console */
+    debugMode?: boolean;
+    /** Eventuali proprietà di default per l'EsTable */
+    defaults?: EsTableDefaultable;
+    /** Espressione ACL globale per definire se i tasti di download sono abilitati o no. Override a livello massimo */
+    globalExportAclExpression?: string;
+}
+
+/** Componente rappresentante una Colonna della tabella */
+declare class EsTh {
+    private myself;
+    private renderer;
+    /** Dizionario di mappatura con ordinamento attuale e ordinamento successivo per gestire i passaggi di stato */
+    private orderNext;
+    /** Indicazione sulla visibilità della colonna */
+    private _Visible;
+    /** Indica se si sta effettuando un'operazione di resize su questa colonna */
+    private resizingThis;
+    /**
+     * Storicizza l'offset di partenza del resize dell'elemento HTML per poter calcolare la nuova dimensione richiesta durente il resize
+     *
+     * nuova width = startOffset + posizione X del mouse
+     */
+    private startOffset;
+    /** Id della colonna, dev'essere lo stesso per tutti gli **EsTd** relativi */
+    ID: _angular_core.InputSignal<string>;
+    /** Ordinamento attuale della colonna */
+    _Order: _angular_core.InputSignal<"DESC" | "ASC">;
+    Order: WritableSignal<"DESC" | "ASC">;
+    /** Indica se questa colonna è ordinabile o meno */
+    Orderable: _angular_core.InputSignal<boolean>;
+    /** Valore da mostrare all'interno della colonna. Se omesso verrà proiettato il contenuto dal template in cui è stata usata */
+    Display: _angular_core.InputSignal<string>;
+    /** Indica se le dimnsioni di questa colonna sono modificabili o meno */
+    Resizable: _angular_core.InputSignal<boolean>;
+    /** Indica se questo header è pinnato. In caso lo fosse presenta il tastino per effettuare lo spinning */
+    Pinned: _angular_core.InputSignal<boolean>;
+    /**
+     * Indica se sta venendo eseguita una operazione di ricerca o meno, serve per evitare l'esecuzione di eventuale codice che potrebbe dare fastidio
+     * come ad esempio l'escuzione di un ordinamento durante il caricamento di dati nuovi
+     */
+    SearchInProgress: _angular_core.InputSignal<boolean>;
+    /** Impostato dall'**EsTable**, serve per permettere o meno di effettuare ordinamenti dati su questa colonna */
+    OrderBy: _angular_core.InputSignal<boolean>;
+    /** Indica se il testo presente in questo Header può andare a capo o meno, di default non può */
+    Wrap: _angular_core.InputSignal<boolean>;
+    /** Indica se la colonna è fixed, cioè se non può né essere nascosta, né riposizionata. Solo le prime colonne possono essere Fixed */
+    Fixed: _angular_core.InputSignal<boolean>;
+    /** Template Angular da istanziare per questo TH */
+    Template?: any;
+    /** Evento emesso al cambio di ordinamento effettuato su questa colonna */
+    onOrderChange: EventEmitter<'DESC' | 'ASC' | null>;
+    /** Evento emesso all'unpinning della colonna */
+    onUnpinning: EventEmitter<string>;
+    /** Proiezione del contenuto di questa colonna */
+    content: ElementRef;
+    /** Classi da applicare alla colonna */
+    Class: WritableSignal<string>;
+    /** Impostato dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
+    _referenced: WritableSignal<boolean>;
+    /** Variabile finale su cui è bindato il contenuto della cella. Sarà valorizzato a **Display** se specificato, all'**innerHTML** dell'elemento proiettato altrimenti */
+    Description: _angular_core.Signal<string>;
+    private setUnderlyingSignal;
+    /** @ignore */
+    constructor(myself: ElementRef, renderer: Renderer2);
+    /**
+     * Imposta la visibilità o meno della colonna, si traduce nell'applicazione o rimozione della classe **app-display-none**
+     *
+     * @param {boolean} expression Indicazione della visibilità
+     */
+    set Visible(expression: boolean);
+    /**
+     * Restituisce lo stato di Visibilità della colonna in oggetto
+     *
+     * @returns {boolean} **true** se visibile, **false** altrimenti
+     */
+    get Visible(): boolean;
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** Emette l'evento di unpinning */
+    unpin(): void;
+    /** Gestisce la modifica dell'ordinamento qualora venisse cliccato su questa colonna */
+    setupNextOrderAndNotify(): void;
+    /**
+     * Evento di inizio resize della colonna
+     *
+     * @param {any} ev Evento MouseDown
+     */
+    onResizeStart(ev: any): void;
+    /** Listener per la fine dell'operazione di resize */
+    onMouseUp(): void;
+    /**
+     * Listener per gestire il movimento del mouse qualora un'operazione di resize fosse in esecuzione
+     *
+     * @param {$event} ev Evento MouseMove
+     */
+    onMouseMove($event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTh, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EsTh, "[es-th]", never, { "ID": { "alias": "es-th"; "required": false; "isSignal": true; }; "_Order": { "alias": "Order"; "required": false; "isSignal": true; }; "Orderable": { "alias": "Orderable"; "required": false; "isSignal": true; }; "Display": { "alias": "Display"; "required": false; "isSignal": true; }; "Resizable": { "alias": "Resizable"; "required": false; "isSignal": true; }; "Pinned": { "alias": "Pinned"; "required": false; "isSignal": true; }; "SearchInProgress": { "alias": "SearchInProgress"; "required": false; "isSignal": true; }; "OrderBy": { "alias": "OrderBy"; "required": false; "isSignal": true; }; "Wrap": { "alias": "Wrap"; "required": false; "isSignal": true; }; "Fixed": { "alias": "Fixed"; "required": false; "isSignal": true; }; "Template": { "alias": "Template"; "required": false; }; "Visible": { "alias": "Visible"; "required": false; }; }, { "onOrderChange": "onOrderChange"; "onUnpinning": "onUnpinning"; }, never, ["*"], false, never>;
+}
+
+declare class EstFormatPipe implements PipeTransform {
+    private dates;
+    constructor(dates: DateService);
+    transform(value: string, format: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstFormatPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstFormatPipe, "est_format", false>;
+}
+
+declare class EstLookupPipe implements PipeTransform {
+    transform(value: string, source: {
+        id: string;
+        description: string;
+    }[]): {
+        id: string;
+        description: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstLookupPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstLookupPipe, "est_lookup", false>;
+}
+
+declare class EstRouterLinkPipe implements PipeTransform {
+    /** Cache per i routerLink generati nelle tabelle dinamiche */
+    routerLinksCache: {};
+    transform(item: any, path: string, parameters: string[]): any;
+    /**
+     * Crea un router link
+     *
+     * @param {string} path Path su cui navigare con eventuali parametri riferiti all'oggetto cotnestuale come {0}, {1}, ecc...
+     * @param {string[]} pars Lista posizionale delle proprietà a cui bindare i riferimenti del parametro **path**
+     * Es. Il valore dela proprietà all'indice 0 di questo array verrà sostituita al valore {0} del parametro **path**
+     * @param {any} item Oggetto collegato a questo contesto. Può essere un oggetto generico (con "properties") o un oggetto ben definito
+     *
+     * @returns {any} Router link generato in base al parametri
+     */
+    private getRouterLink;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstRouterLinkPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstRouterLinkPipe, "est_routerlink", false>;
+}
+
+declare class EstRendererPipe implements PipeTransform {
+    private logger;
+    constructor(logger: Logger);
+    transform(propName: string, params: {
+        name: string;
+        src: QueryList<EsTdDirective>;
+        fallback: any;
+    }): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstRendererPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstRendererPipe, "est_renderer", false>;
+}
+
+declare class EstEditorPipe implements PipeTransform {
+    private logger;
+    constructor(logger: Logger);
+    transform(propName: string, params: {
+        name: string;
+        src: QueryList<EsTdEditorDirective>;
+        fallback: any;
+    }): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstEditorPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstEditorPipe, "est_editor", false>;
+}
+
+declare class EstPropInsensitivePipe implements PipeTransform {
+    transform(item: any, property: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EstPropInsensitivePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstPropInsensitivePipe, "est_propinsensitive", false>;
+}
+
+declare class EsTableModule {
+    static forRoot(config?: EsTableModuleConfig): ModuleWithProviders<EsTableModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTableModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<EsTableModule, [typeof EsTdDirective, typeof EsThDirective, typeof EsTdEditorDirective, typeof EsTableComponent, typeof EsTablePagerComponent, typeof ThTdProvider, typeof EsTh, typeof EsTd, typeof EstFormatPipe, typeof EstLookupPipe, typeof EstRouterLinkPipe, typeof EstRendererPipe, typeof EstEditorPipe, typeof EstPropInsensitivePipe], [typeof i15.CommonModule, typeof i16.FormsModule, typeof i17.RouterModule, typeof i18.LocalizationModule, typeof i19.ModalModule, typeof i20.BsDropdownModule, typeof i21.ContextMenuModule, typeof i22.DragDropModule, typeof i23.FormsAndValidationsModule, typeof i24.TooltipModule, typeof i25.AccessControlModule, typeof i26.SelectModule], [typeof EsTdDirective, typeof EsThDirective, typeof EsTdEditorDirective, typeof EsTableComponent, typeof EsTablePagerComponent, typeof ThTdProvider]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<EsTableModule>;
+}
+
+/** Classe che definisce un oggetto generico come lista di proprietà-valore */
+declare class GenericItem {
+    /** @ignore */
+    constructor();
+    /** Dizionario delle proprietà dell'oggeto con il loro valore */
+    properties: Record<string, string>;
+    /** Indica se l'oggetto in questione è selezionato o meno */
+    _selected: boolean;
+    /** Viene valorizzato da un eventuale **RowClassAssigner** (o automaticamente se in modalità gerarchica) e serve applicare stili particolari alla intera riga */
+    _rowClass: string;
+    /** Hash dell'oggetto per generare i contesti di bind all'interno dell'es-table (vedere eventualmente l'implementazione specifica) */
+    _hash: string;
+}
+
+/** Classe che definisce un multi-elemento, cioè una proprietà particolare di un oggetto da visualizzare in es-table che genera dinamicamente gruppi di Header e valori sottostanti */
+declare class EsTableMultiValue {
+    value: any;
+    header: string;
+    header_group: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} value Valore di questo elemento
+     * @param {string} header Nome di questo header
+     * @param {string} header_group Gruppo dell'header, in caso di multipli gruppi innestati usare la sintassi "G1 > G2 > G3" ecc...
+     * @param {boolean} exports Indica se questo header con questo valore dev'essere esportato
+     * @param {string} export_format Qualora **export** fosse **true** indica il formato per l'esportazione
+     */
+    constructor(value: any, header: string, header_group: string, exports?: boolean, export_format?: string);
+    /** Indica se questo header con questo valore dev'essere esportato */
+    exports?: boolean;
+    /** Qualora **export** fosse **true** indica il formato per l'esportazione */
+    export_format?: string;
+    /** Generato automaticamente da **header_group** se passato da costruttore, altrimenti generato da es-table. Contiene la lista di gerarchie degli header groups (cioè **header_group** splittato su ">" e trimmato) */
+    _headersHierarchy?: string[];
+}
+
+/** Classe che rappresenta i valori delle proprietà di un oggetto Report */
+declare class ReportRow {
+    /** Valori dell'oggetto in ordine sequenziale */
+    values: string[];
+    /** Colore di foreground per ogni cella */
+    forecolors?: string[];
+    /** Colore di background per ogni cella */
+    backcolors?: string[];
+}
+
+/** Token che indica se emettere log a console o meno */
+declare const EST_DEBUG: InjectionToken<string>;
+/** Token che indica l'espressione ACL da utilizzare (if any) per consentire le operazioni di esportazione */
+declare const EST_EXPORT_GLOBAL_ACL: InjectionToken<string>;
+/** Token che indica i default da assegnare agli Input */
+declare const EST_DEFAULTS: InjectionToken<EsTableDefaultable>;
+
+export { AppOrdering, AppSearch, CornerMenuOption, EST_DEBUG, EST_DEFAULTS, EST_EXPORT_GLOBAL_ACL, EsTableColumnsDefinition, EsTableComponent, EsTableDefaultable, EsTableModelChange, EsTableModule, EsTableModuleConfig, EsTableMultiValue, EsTableOperationDefinition, EsTablePagerComponent, EsTdDirective, EsTdEditorDirective, EsTdReference, EsThDirective, GenericItem, Group, GroupAggregation, GroupFilter, GroupOrAggregation, ItemPropEditableReference, ItemsSelection, ReportColumn, ReportParam, ReportRow, ThTdProvider };
+export type { InputType };