@esfaenza/es-table 11.2.22-beta6 → 11.2.23

package/lib/es_table.component.d.ts

@@ -1,1186 +0,0 @@
-import { QueryList, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, ElementRef, TemplateRef } from '@angular/core';
-import { ControlValueAccessor, NgControl } from '@angular/forms';
-import { HashingService, UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';
-import { LocalizationService } from '@esfaenza/localizations';
-import { PreferencesService } from '@esfaenza/preferences';
-import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
-import { AppSearch, AppOrdering, GenericItem, EsTableColumnsDefinition, CornerMenuOption, ReportResult, ReportColumn, EsTableOperationDefinition, EsTableColumn, GroupPager } from './domain';
-import { EsTd } from './es_td.component';
-import { EsTdDirective } from './directives/es_td.directive';
-import { EsThDirective } from './directives/es_th.directive';
-import { ItemsSelection } from './domain/externals/classes/appsearch/ItemsSelection';
-import { Group } from "./domain/externals/classes/appsearch/Group";
-import { EsTableDefaultable } from './models/EsTableDefaultable';
-/** Componente che permette di rappresentare una griglia di valori */
-export declare class EsTableComponent implements ControlValueAccessor, OnChanges {
-    ngControl: NgControl;
-    private prefService;
-    private deafults;
-    locale: string;
-    lc: LocalizationService;
-    private cdr;
-    private hashExts;
-    private utiExts;
-    private expExts;
-    private dateExts;
-    private msgExts;
-    /** @ignore */
-    constructor(ngControl: NgControl, prefService: PreferencesService, deafults: EsTableDefaultable, locale: string, lc: LocalizationService, cdr: ChangeDetectorRef, hashExts: HashingService, utiExts: UtilityService, expExts: ExportService, dateExts: DateService, msgExts: MessageService);
-    /** View finale su cui bindarsi lato Frontend, il tipo può essere IAppSearch<any> (per la **viewMode**), any[] (per l'**arrayMode**) e ReportDefinition per la **reportMode** */
-    View: any;
-    /** Modello da cui l'es-table mostra i pulsanti di paginazione in basso a destra */
-    arrayPulsanti: any;
-    /** Indica se l'es-table deve mostrare il check globale nell'header per fare il "seleziona tutto" */
-    globalCheck: boolean;
-    /** Tiene da conto l'ultimo elemento selezionato in modo da poter effettuare il SHIFT+CLICK */
-    private lastSelected;
-    /** Conteggio interno per il numero di elementi selezionati */
-    selectedObjects: number;
-    /** Indica se è possibile effettuare una selezione massiva */
-    canSelectAll: boolean;
-    /** Indica se il componente sta gestendo un IAppSearch<any> */
-    viewMode: boolean;
-    /** Indica se il componente sta gestendo un any[] */
-    arrayMode: boolean;
-    /** Indica se il componente sta gestendo un ReportDefinition */
-    reportMode: 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: any[];
-    /** Stessa cosa della **boundSource**, utilizzata come appoggio temporaneo interno */
-    TMPBoundSource: any[];
-    /** "Fetta" di oggetti utilizzata nell'endless scroll, ogni elemento di questo array è un blocchetto di 100 elementi */
-    boundSubSources: any[];
-    /** 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;
-    /** Indica se utilizzare il sistema di Endless Scroll */
-    UseEndlessscroll: boolean;
-    /** Valori dell'eventuale report in visualizzazione */
-    ReportValues: ReportResult;
-    /** 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: boolean;
-    /** Numero di secondi da fare trascorrere fra una ricerca e l'altra */
-    seconds: 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: boolean;
-    /** Modello rappresentante un singolo td della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
-    RowTDs: {
-        [context: string]: EsTd[];
-    };
-    /** Modello di appoggio temporaneo per i **RowTDs** */
-    TMPRowTDs: {
-        [context: string]: EsTd[];
-    };
-    /** Modello rappresentante un singolo th della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
-    RowTHs: {
-        Pinned: boolean;
-        Fixed: boolean;
-        ID: string;
-        Visible: boolean;
-        Class: string;
-        Content: string;
-        Order: string;
-        Orderable: boolean;
-        Template: TemplateRef<any>;
-        Wrap: boolean;
-    }[];
-    /** Modello di appoggio temporaneo per i **RowTHs** */
-    TMPRowTHs: {
-        Pinned: boolean;
-        Fixed: boolean;
-        ID: string;
-        Visible: boolean;
-        Class: string;
-        Content: string;
-        Order: string;
-        Orderable: boolean;
-        Template: TemplateRef<any>;
-        Wrap: boolean;
-    }[];
-    /** Modello di appoggio temporaneo per i **RowThGroups** */
-    TMPRowThGroups: {
-        Span: number;
-        Template: TemplateRef<any>;
-    }[][];
-    /** Modello rappresentante un singolo header group della tabella. Questa lista è già ordinata e pronta per essere utilizzata in ngFor */
-    RowThGroups: {
-        Span: number;
-        Template: TemplateRef<any>;
-    }[][];
-    /** Cache per i routerLink generati nelle tabelle dinamiche */
-    DynamicTableRouterLinkCache: {};
-    /**
-     * 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;
-    /**
-     * 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: boolean;
-    /** Indica che questo è il primo Bind della tabella, viene settato a false non appena il primo bind viene terminato con successo */
-    FirstBind: 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: boolean;
-    /** 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>;
-    /** @deprecated Query per recuperare tutti gli es-th */
-    private EsThs;
-    /** @deprecated Query per recuperare tutti gli es-td */
-    private EsTds;
-    /** @deprecated Query per recuperare le informazioni del body (punto della tabella dove vengono mostrate le righe) */
-    bodyRef: any;
-    /** @deprecated Query per recuperare le informazioni dell'header (punto della tabella dove vengono mostrate le intestazioni delle righe) */
-    headerRef: any;
-    /** Query per recuperare le informazioni sul raggruppamento degli header */
-    headerGroupRef: any;
-    /** Query per recuperare le informazioni sul raggruppamento di secondo livello degli header */
-    secondaryHeaderGroupRef: any;
-    /** Opzioni extra che devono apparire nel Menù contestuale in alto a destra, richiamato dai 3 pallini verticali */
-    CornerMenuOptions: CornerMenuOption[];
-    /** Indica se dev'essere possibile effettuare il resize delle colonne */
-    ColumnsResizable: boolean;
-    /** Indica se dev'essere disponibile il sistema di aggiornamento automatico */
-    AutoUpdate: boolean;
-    /** Indica se la tabella (configurata con **UseCustomCells**) deve mettersi in ascolto per i click sulle celle desiderate
-     *
-     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
-     */
-    UseCustomCellActions: boolean;
-    /**
-     * Indica le celle desiderate su cui intercettare i click. Attiva solo quando **UseCustomCellActions** è true.
-     * Ogni cella dev'essere separata dalla successiva dal carattere del Simoleon:
-     *
-     * Es, "MiaCella1§MiaCella2"
-     *
-     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
-     */
-    CustomCellActionsOn: string;
-    /**
-     * Serve per decidere di lanciare o meno il **event.stopPropagation()** al termine della gestione dell'evento
-     *
-     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
-     */
-    CellActionPropagates: boolean;
-    /**
-     * 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...
-     */
-    UseCustomCells: boolean;
-    /** Permette di impostare l'altezza massima della tabella. Se null la dimensione si adatta al numero di elementi attualmente in visualizzazione */
-    MaxHeight: number;
-    /** Classi da applicare al contenitore della tabella */
-    ContainerClass: any;
-    /** Permette o meno l'export in formato XLSX */
-    XLSXExport: boolean;
-    /** Permette o meno l'export in formato CSV */
-    CSVExport: boolean;
-    /** Permette di visualizzare o meno l'opzione di paginazione "Tutti" */
-    AllSearch: any;
-    /** 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: boolean;
-    /** Abilita o meno la possibilità di selezionare oggetti */
-    Selection: boolean;
-    /** Mostra o meno un messaggio di Loading al primo caricamento della tabella */
-    ShowLoadingOnBootstrap: boolean;
-    /** Se impostato a **true** aggiunge una colonna con pulsante di eliminazione per effettuare l'elimina dell'oggetto relativo */
-    Removal: 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: string;
-    /** Indica se abilitare la possibilità di esportare la vista dati attuale */
-    Export: boolean;
-    /** Indica se permettere la selezione multipla Windows-like cliccando un oggetto e facendo poi Shift + click su un oggetto successivo */
-    ShiftClick: boolean;
-    /** Indica se nascondere o mostrare il componente di paginazione */
-    HidePaging: boolean;
-    /** Indica se nascondere o mostrare il conteggio degli elementi trovati */
-    HidePagingCount: boolean;
-    /** Indica se nascondere o mostrare i pulsanti di paginazione */
-    HidePagingButtons: 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: string;
-    /** Classe (HTML) di default della tabella */
-    TableClass: any;
-    /**
-     * Funzione da utilizzare in esportazione. Nel formato "Report" avrà un unico parametro "Formato" e nessun valore di ritorno.
-     *
-     * Nel formato "View" ha come parametro una callback con i dati completi da esportare (dato che di default la ricerca è paginata)
-     */
-    ExportFunction: any;
-    /** @deprecated Indica la presenza di raggruppamenti a livello di header */
-    HasHeaderGroup: boolean;
-    /** @deprecated Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */
-    HasSecondaryHeaderGroup: boolean;
-    /** Utilizzato per dividere la sorgente in modalità EndlessScroll */
-    SliceSize: number;
-    /** Decide se utilizzare la modalità di EndlessScroll */
-    EndlessScroll: boolean;
-    /** Qualora **EndlessScroll** fosse true, indica se utilizzare questa modalità solo quando si cerca per "Tutti" o in generale */
-    EndlessScrollOnlyForAll: boolean;
-    /** Indica se nascondere gli Header della tabella */
-    HeaderHidden: boolean;
-    /** Indica se nascondere il Body della tabella */
-    BodyHidden: 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: 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: boolean;
-    /** Callback che dato un oggetto resituisce l'eventuale classe da applicare alla riga collegata all'oggetto */
-    RowClassAssigner: any;
-    /** Permette di ordinare i dati in maniera discendente o ascendente */
-    OrderByColumn: boolean;
-    /** Permette di avere più direttive di ordinamento dei dati */
-    MultipleOrderingDirectives: boolean;
-    /** Permette di nascondere le colonne in base alle selezioni effettuate dal Menù contestuale in alto a destra */
-    HiddenColumns: boolean;
-    /** Permette di riordinare le colonne in base alle impostazioni effettuate dal Menù contestuale in alto a destra */
-    ColumnsOrdering: boolean;
-    /** Eventuale supporto alle ricerche applicate alla modalità Array */
-    SearchView: AppSearch<any>;
-    /** Abilita o disabilita il sistema che permette di selezionare tutti gli elementi nella vista */
-    SelectAll: boolean;
-    /** Simula la paginazione anche per le tabelle che funzionano in modalità Array */
-    UseArrayModePaging: boolean;
-    /** Definizione di colonne dinamche per la modalità, appunto, dinamica */
-    DynamicRowColumnsDefinition: EsTableColumnsDefinition[];
-    /** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
-    DynamicOperations: EsTableOperationDefinition[];
-    /** Indica se visualizzare i dati in maniera gerarchica */
-    Hierarchy: boolean;
-    /** Nome della proprietà che contiene l'ID del padre. Da utilizzare se **Hierarchy** è impostato */
-    ParentKey: string;
-    /** Nome della proprietà che contiene l'ID dell'oggetto attuale. Da utilizzare se **Hierarchy** è impostato */
-    OwnKey: string;
-    /** Indica se partire con un albero espanso. Da utilizzare se **Hierarchy** è impostato */
-    StartsExpanded: boolean;
-    /** Indica se effettuare il salvataggio delle preferenze di ricerca */
-    SavePreferences: boolean;
-    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
-    PagingStyle: 'both' | 'top' | 'bottom';
-    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
-    RowGroupingPagingStyle: 'left' | 'right';
-    /**
-     * Sorgente dati secondaria
-     *
-     * @deprecated Utilizzato solo per un caso particolare del Metering
-     */
-    SecondarySource: boolean;
-    /**
-     * Sorgente dati secondaria
-     *
-     * @deprecated Utilizzato solo per un caso particolare del Metering
-     */
-    TertiarySource: boolean;
-    /** 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: any;
-    /** Permette di decidere se, in modalità raggruppamento, mostrare o meno il valore delle colonne di gruppo negli oggetti finali. Di default sono nascosti */
-    ShowItemGroupsColumns: any;
-    /** 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 al click su una cella quando **UseCustomCellActions** è attivo
-     *
-     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
-     */
-    onCellClick: EventEmitter<{
-        column: string;
-        model: any;
-    }>;
-    /** 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;
-    }>;
-    /** Dati esportati da ngx-csv */
-    data: any[];
-    /** Header dei dati esportati da ngx-csv */
-    headers: 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: any;
-    /** 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
-     */
-    private groupSearchRequestsCache;
-    /** 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: {
-        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" */
-    private BaseItemsCount;
-    /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */
-    private rgGroupCache;
-    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
-    private rgItemCache;
-    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
-    private rgChildGroupsCache;
-    /** 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;
-    /** Indica se ci sono delle colonne pinnate e visibili. Serve per poter settare tutte le colonne prima che arrivino dati a pinned*/
-    HasPinnedColumns: boolean;
-    /** Larghezza calcolata del container delle colonne pinnate */
-    PinnedContainerWidth: 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: boolean;
-    PagerOptions: {
-        PagerCount: number;
-        ShowCount: boolean;
-        ShowPaging: boolean;
-        UsesView: boolean;
-        View: any;
-        Ready: boolean;
-        Searches: 'items' | 'groups';
-    };
-    /** @ignore */
-    ngOnInit(): void;
-    /** @ignore */
-    ngAfterViewInit(): 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
-     */
-    private InputOrDefault;
-    /** @ignore */
-    ngOnDestroy(): void;
-    /** @ignore */
-    ngOnChanges(changes: SimpleChanges): Promise<void>;
-    /** @ignore */
-    registerOnChange(fn: any): void;
-    /** @ignore */
-    registerOnTouched(fn: any): void;
-    /** @ignore */
-    changed(): void;
-    /** @ignore */
-    propagateChange: (_: any) => void;
-    /** @ignore */
-    writeValue(obj: any): void;
-    /**
-     * 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;
-    /**
-     * Ripulisce le cache di selezione
-     *
-     * @todo: SELECTION
-     */
-    private clearSelectionCaches;
-    /**
-     * 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
-     *
-     * @todo: ITEMS
-     */
-    private getItemsByMode;
-    /**
-     * @ignore
-     *
-     * @todo: ITEMS
-     */
-    private getViewItemsBySource;
-    /**
-     * Helper per effettuare il caching delle aggregazioni. Le sposta da una lista di **GroupAggregation** a una **<Map<string, Map<string, string>>**
-     *
-     * @todo: ROWGROUPING
-     */
-    private cacheAggregations;
-    /**
-     * Metodo che prende tutti gli oggetti di cui dispone divisi in bucket da 100 elementi
-     *
-     * @returns {any[][]} Matrice di array Nx100
-     *
-     * @todo: ITEMS
-     */
-    private getItemSlices;
-    /**
-     * Metodo che gestisce l'endless scroll e in base a quanto la tabella è stata scrollata aggiunge degli elementi extra a **TMPBoundSource**
-     *
-     * @param {any} e Evento di scroll del browser
-     */
-    onScroll(e: any): void;
-    /**
-     * 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;
-    /**
-     * Se in modalità array applica gli ordinamenti ASC-DESC delle colonne
-     *
-     * @todo: INTERNALDB
-     */
-    private arrayModeReviewOrderings;
-    /**
-     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
-     *
-     * @param {ths: EsTh[] | EsThDirective[]} ths Header
-     *
-     * @todo: ROW GROUPING
-     */
-    private arrayModeReviewGroupings;
-    /**
-     * 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
-     *
-     * @todo: INTERNALDB
-     */
-    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
-     *
-     * @todo: INTERNALDB
-     */
-    private generateAggregations;
-    /**
-     * 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
-     *
-     * @todo: INTERNALDB
-     */
-    private groupBy;
-    /**
-     * 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;
-    /**
-     * 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
-     *
-     * @todo: ROWGROUPING
-     */
-    private handleNewDataOnRowGrouping;
-    /**
-     * Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML
-     */
-    private MoveTemporaryVariablesToRealOnes;
-    /**
-     * 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
-     *
-     * @todo: SELECTION
-     */
-    setSelectionStatus(items: any[], select: boolean): void;
-    /**
-     * Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna
-     */
-    private eventuallyReviewDynamicColumns;
-    /**
-     * Partendo dagli **EsThs** estrappolo la lista di **EsTableColumn** che questa tabella dovrà eventualmente gestire per Visibilità e Ordine
-     *
-     * Costo: 1 scan EsThs
-     *
-     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
-     */
-    private reviewColumnsList;
-    /**
-     * Prende i th e i td in modalità diretive e li ordina in base a se ci sono colonne fixed o meno
-     */
-    private moveFixedColumnsAtTheBeginning;
-    /**
-     * In base alla configurazione delle colonne calcola le dimenioni delle colonne pinnate
-     */
-    private evaluatePinnedColumnsWidth;
-    /**
-     * Helper per spostare un oggetto di un array da un indice all'altro, in place
-     */
-    private arrayMove;
-    /**
-     * 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
-     */
-    private alignColumnsIfLoadedView;
-    /**
-     * 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
-     */
-    private emitSearchRequest;
-    /**
-     * In base alla visibilità registrata nelle **ColumnsList** questo metodo si occupa di prendere tutti i **EsThs** ed **EsTds** relativi e nasonderli/mostrarli
-     *
-     * Costo: 1 scan ColumnsList, 1 scan EsThs, 1 scan EsTds
-     *
-     * @param {EsTh[] | EsThDirective[]} ths Header della tabella
-     * @param {EsTd[] | EsTdDirective[]} tds Celle della tabella
-     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
-     */
-    private refreshColumnsVisibility;
-    /**
-     * 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 {EsTh[] | EsThDirective[]} ths Colonne della tabella
-     */
-    private alignHeadersOrdering;
-    /**
-     * 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 {EsTh[] | EsThDirective[]} ths Colonne della tabella
-     * @param {EsTd[] | 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
-     *
-     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
-     */
-    private evaluateRowThs;
-    private evaluateHeadersGroupingInfos;
-    /**
-     * Genera gli header groups da una lista di info sui th all'interno della variabile **TMPRowThGroups**
-     */
-    private evaluateHeaderGroups;
-    /**
-     * Calcola il numero di salti da un header foglia all'ultimo parent della catena
-     */
-    private jumpsToFinalParent;
-    /**
-     * 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
-     */
-    private getGroupAggregations;
-    /**
-     * 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;
-    /**
-     * Metodo che genera l'ordine di default delle colonne
-     *
-     * @param {AppSearch<any>} view AppSearch da utilizzare per questa operazione
-     */
-    private generateDefaultOrder;
-    /**
-     * 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
-     */
-    private applyOrdering;
-    /**
-     * 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
-     */
-    private getGroupSeparator;
-    /**
-     * 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;
-    /**
-     * 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
-     *
-     * @todo: Testare
-     */
-    private emitRowGroupingSearches;
-    /**
-     * 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**
-     */
-    private getGroupCellDisplay;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Sul click nella checkbox di selezione globale si scorrono tutte le colonne e si impostano al valore della check globale
-     */
-    globalColVisCheckChanged(): void;
-    /**
-     * 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
-     */
-    private assignHierarchyLevels;
-    /**
-     * 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;
-    /**
-     * 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
-     */
-    private evaluateSelection;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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: L'array degli oggetti e le due cache
-     */
-    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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Effettua l'esportazione dei dati
-     *
-     * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
-     */
-    tryExport(format?: string): void;
-    /**
-     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
-     *
-     * @param {any[]} items Oggetti da esportare
-     */
-    private setupExport;
-    /**
-     * Sul click dell'Header di una colonna questo metodo si occupa di applicare l'ordinamento successivo e di notificare con **emitSearchRequest**
-     * il bisogno di aggiornare i dati da parte del componente che utilizza la tabella
-     *
-     * Utilizzato solo in modalità REport
-     *
-     * @param {ReportColumn} clm Colonna del report per cui ordinare
-     */
-    setupNextOrderAndSearch(clm: ReportColumn): void;
-    /**
-     * Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello
-     */
-    private reviewReportBindings;
-    /**
-     * 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
-     *
-     * @returns {TemplateRef<any>} Template da usare per la colonna
-     */
-    findEsTd(column: string): TemplateRef<any>;
-    /**
-     * Metodo di supporto alla creazione di un router link parametrizzato all'oggetto corrente utilizzato nella modalità dinamica
-     *
-     * @param {string} path Path su cui navigare con eventuali parametri riferiti all'oggetto cotnestuale come {0}, {1}, ecc...
-     * @param {string[]} parameterProps 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 {GenericItem} item Oggetto generico collegato a questo contesto
-     *
-     * @returns {any} Router link generato in base al parametri
-     */
-    generateRouterLink(path: string, parameterProps: string[], item: GenericItem): 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 {GenericItem} item Oggetto generico collegato a questo contesto
-     *
-     * @returns {any} Router link generato in base al parametri
-     */
-    private getRouterLink;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata
-     */
-    private adaptViewToPaging;
-    /**
-     * Gestore dei click sulle celle per le quali era impostata una azione custom da **CustomCellActionsOn**
-     *
-     * @param {string} name Nome della cella su cui si è fatto click
-     * @param {any} model Modello relativo alla cella cliccata
-     *
-     * @returns {boolean} **true** se il click è stato fatto su una cella cliccabile, **false** altrimenti
-     */
-    cellClicked(name: string, model: any): boolean;
-    /**
-     * 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;
-    /** Helper che identifica se il td attuale è di tipo **EsTd**. In caso contrario è da considerarsi **EsTdDirective** */
-    private isEsTd;
-    /**  Helper che identifica se il th attuale è di tipo **EsTh**. In caso contrario è da considerarsi **EsThDirective** */
-    private isEsTh;
-    /** Impostazione modalità dell'EsTable */
-    private setMode;
-    /**
-     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**,
-     * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
-     */
-    private internalWriteValue;
-    /**
-     * 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
-     */
-    private getPagesArray;
-    /**
-     * Calcola l'hash di un oggetto qualsiasi
-     *
-     * @param {any[]} items Oggetti per cui calcolare l'hash
-     */
-    private calculateHash;
-    /**
-     * Metodo eventualmente richiamabile anche dal componente esterno che permette di forzare un refresh della tabella
-     */
-    forceRefresh(): void;
-}