@esfaenza/es-table 20.3.13 → 20.3.15

package/index.d.ts

@@ -1,27 +1,27 @@
 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 { ChangeDetectorRef, EventEmitter, WritableSignal, Signal, TemplateRef, ElementRef, QueryList, NgZone, Renderer2, Type, AfterContentInit, OnDestroy, PipeTransform, ModuleWithProviders, InjectionToken } from '@angular/core';
+import * as i22 from '@esfaenza/localizations';
 import { LocalizationService } from '@esfaenza/localizations';
-import * as i19 from '@esfaenza/extensions';
+import * as i23 from '@esfaenza/extensions';
 import { MessageService, ExportService, UtilityService, DateService, HashingService, ClipboardService, AppEmbeddingExtensions } from '@esfaenza/extensions';
-import * as i16 from '@angular/forms';
+import * as i20 from '@angular/forms';
 import { ControlValueAccessor, NgControl } from '@angular/forms';
 import { PreferencesService } from '@esfaenza/preferences';
-import * as i22 from '@esfaenza/ngx-contextmenu';
+import * as i26 from '@esfaenza/ngx-contextmenu';
 import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
-import * as i20 from 'ngx-bootstrap/modal';
+import * as i24 from 'ngx-bootstrap/modal';
 import { ModalDirective } from 'ngx-bootstrap/modal';
 import { SafeHtml } from '@angular/platform-browser';
 import { ReplaySubject, Subject } from 'rxjs';
-import * as i23 from '@angular/cdk/drag-drop';
+import * as i27 from '@angular/cdk/drag-drop';
 import { CdkDragDrop, CdkDrag } from '@angular/cdk/drag-drop';
-import * as i15 from '@angular/common';
-import * as i17 from '@angular/router';
-import * as i21 from 'ngx-bootstrap/dropdown';
-import * as i24 from '@esfaenza/forms-and-validations';
-import * as i25 from 'primeng/tooltip';
-import * as i26 from '@esfaenza/access-control';
-import * as i27 from 'primeng/select';
+import * as i19 from '@angular/common';
+import * as i21 from '@angular/router';
+import * as i25 from 'ngx-bootstrap/dropdown';
+import * as i28 from '@esfaenza/forms-and-validations';
+import * as i29 from 'primeng/tooltip';
+import * as i30 from '@esfaenza/access-control';
+import * as i31 from 'primeng/select';
 
 /** Componente che si occupa della paginazione di una tabella */
 declare class EsTablePagerComponent {
@@ -1617,7 +1617,13 @@ declare class Logger {
     debugMode: boolean;
     /** @ignore */
     constructor(debugMode: boolean);
-    log(text: string): void;
+    /**
+     * Emette un log a console solo se la modalità debug è attiva.
+     *
+     * Il testo può essere passato come funzione (**lazy**): in tal caso viene valutato solo quando il debug è attivo,
+     * evitando di costruire stringhe costose (es. interpolazioni per-cella) quando i log sono disabilitati.
+     */
+    log(text: string | (() => string)): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Logger, [{ optional: true; }]>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<Logger>;
 }
@@ -2346,6 +2352,587 @@ declare class EsTableModuleConfig {
     globalExportAclExpression?: string;
 }
 
+/** Specifica di una singola aggregazione estratta da un template `{func:format}` */
+interface Est2AggSpec {
+    /** Colonna su cui calcolare l'aggregazione */
+    column: string;
+    /** Funzione di aggregazione */
+    func: 'min' | 'max' | 'sum';
+    /** Formato di visualizzazione (F0-F9 per numeri, small/long/verylong per date) */
+    format: string;
+    /** Testo esatto del token da rimpiazzare nel template (es. `{sum:F2}`) */
+    match: string;
+    /** Tipo di dato dedotto dal formato */
+    datatype: 'string' | 'date' | 'number';
+}
+
+/** Modello interno di colonna. Può derivare da direttive `*th`/`*td`, da una
+ *  `EsTableColumnsDefinition` (modalità dinamica) o da una `ReportColumn` (report). */
+interface Est2Column {
+    id: string;
+    /** direttiva header, se la colonna deriva da `*th` */
+    header?: EsThDirective;
+    /** direttiva cella, se la colonna deriva da `*td` */
+    cell?: EsTdDirective;
+    visible: boolean;
+    orderable: boolean;
+    alignment: 'left' | 'right' | 'center';
+    property: string | null;
+    type: string | null;
+    source: {
+        id: any;
+        description: string;
+    }[] | null;
+    format: string | null;
+    cssClass: string;
+    wrap: boolean;
+    /** true se questa colonna è una chiave di raggruppamento (`thGroup`) */
+    isGroup: boolean;
+    /** specifiche di aggregazione parseate dal template `thAggregation` */
+    aggSpecs: Est2AggSpec[];
+    /** testo statico dell'header (modalità dinamica/report; direttive senza template) */
+    headerText?: string | null;
+    /** colore di sfondo dell'header (report) */
+    headerBg?: string | null;
+    /** accesso al valore per indice: report → indice colonna in `values[]` */
+    propAccessor?: string | null;
+    /** indice per il lookup dei colori per-cella (`forecolors[i]`/`backcolors[i]`) in report e dinamica */
+    colorIndex?: number | null;
+    /** route di navigazione per la cella (dinamica) */
+    routePath?: string | null;
+    routeParams?: string[] | null;
+    /** nome del renderer custom da risolvere tra i `*td` (dinamica) */
+    rendererName?: string | null;
+    /** true se la colonna è "pinnata" (sticky a sinistra durante lo scroll orizzontale) */
+    pinned?: boolean;
+    /** larghezza in px della colonna pinnata (usata per calcolare gli offset sticky) */
+    pinnedWidth?: number | null;
+    /** colonna Multi: nome della proprietà-array sull'item (es. `touvalues`) */
+    multiProp?: string | null;
+    /** colonna Multi: indice dell'entry dentro l'array della proprietà */
+    multiIndex?: number | null;
+}
+/** Cella di una riga di header-group multi-livello (span su N colonne-dato). */
+interface Est2HeaderGroupCell {
+    /** id del gruppo, o chiave sintetica per gli spacer */
+    id: string;
+    /** numero di colonne-dato coperte */
+    span: number;
+    /** true se è un vero header di gruppo (ha contenuto), false se spacer vuoto */
+    isGroup: boolean;
+    /** etichetta di fallback (quando non c'è un template proiettato) */
+    label: string;
+    /** template proiettato dell'header di gruppo (contenuto del `*th`) */
+    template: TemplateRef<any> | null;
+}
+/**
+ * es-table2 — riscrittura 2026 dell'es-table.
+ *
+ * Mantiene la superficie pubblica (Input/Output/direttive `*th`/`*td`) dell'es-table
+ * originale ma con implementazione basata su signal, control-flow moderno e un design
+ * system a token (tema chiaro/scuro).
+ *
+ * FASE 1: modalità view/array, celle template + direttive, ordinamento, paginazione,
+ * selezione singola/multipla. Le modalità avanzate (grouping, hierarchy, dynamic,
+ * report, range-paste, export) sono dichiarate nella superficie ma verranno collegate
+ * nelle fasi successive.
+ */
+declare class EsTable2Component implements ControlValueAccessor, AfterContentInit, OnDestroy {
+    ngControl: NgControl;
+    cdr: ChangeDetectorRef;
+    private hostEl;
+    private prefService;
+    private defaults;
+    debugMode: boolean;
+    exportGlobalAcl: string;
+    /** Modalità "template semplice": riga di `<th>` */
+    headerRef?: TemplateRef<any>;
+    /** Modalità "template semplice": riga di `<td>` con `let-item` */
+    bodyRef?: TemplateRef<any>;
+    thDirectives?: QueryList<EsThDirective>;
+    tdDirectives?: QueryList<EsTdDirective>;
+    editorDirectives?: QueryList<EsTdEditorDirective>;
+    /** Context menu (ngx-contextmenu) collegato al click destro sulle righe */
+    ContextMenu?: ContextMenuComponent;
+    /** Menu vuoto di default, usato quando il consumer non fornisce un **ContextMenu** */
+    tableEmptyMenu?: ContextMenuComponent;
+    private ctxMenuSub?;
+    /** Altezza dell'header (misurata): la barra di selezione la usa per coprirlo esattamente */
+    selbarHeight: _angular_core.WritableSignal<number>;
+    private headerEl?;
+    private headerRO?;
+    /** ViewChild-setter: (ri)osserva l'header appena compare/cambia, mantenendo `selbarHeight` allineata */
+    set theadRef(ref: ElementRef<HTMLElement> | undefined);
+    protected readonly _Selection: _angular_core.InputSignal<boolean>;
+    Selection: _angular_core.WritableSignal<boolean>;
+    SingleSelection: _angular_core.InputSignal<boolean>;
+    SelectionDisabled: _angular_core.InputSignal<boolean>;
+    protected readonly _SelectAll: _angular_core.InputSignal<boolean>;
+    SelectAll: _angular_core.WritableSignal<boolean>;
+    protected readonly _UseSelectionCache: _angular_core.InputSignal<boolean>;
+    UseSelectionCache: _angular_core.WritableSignal<boolean>;
+    protected readonly _ShiftClick: _angular_core.InputSignal<boolean>;
+    ShiftClick: _angular_core.WritableSignal<boolean>;
+    protected readonly _OrderByColumn: _angular_core.InputSignal<boolean>;
+    OrderByColumn: _angular_core.WritableSignal<boolean>;
+    MultipleOrderingDirectives: _angular_core.InputSignal<boolean>;
+    Removal: _angular_core.InputSignal<boolean>;
+    RemovalCondition: _angular_core.InputSignal<string>;
+    RowClassAssigner?: (item: any) => string;
+    protected readonly _HidePaging: _angular_core.InputSignal<boolean>;
+    HidePaging: _angular_core.WritableSignal<boolean>;
+    protected readonly _HidePagingCount: _angular_core.InputSignal<boolean>;
+    HidePagingCount: _angular_core.WritableSignal<boolean>;
+    protected readonly _HidePagingButtons: _angular_core.InputSignal<boolean>;
+    HidePagingButtons: _angular_core.WritableSignal<boolean>;
+    protected readonly _AllSearch: _angular_core.InputSignal<boolean>;
+    AllSearch: _angular_core.WritableSignal<boolean>;
+    protected readonly _PagingStyle: _angular_core.InputSignal<"top" | "bottom" | "both">;
+    PagingStyle: _angular_core.WritableSignal<"top" | "bottom" | "both">;
+    protected readonly _ArraymodeItemsPerPage: _angular_core.InputSignal<number>;
+    ArraymodeItemsPerPage: _angular_core.WritableSignal<number>;
+    protected readonly _UseArrayModePaging: _angular_core.InputSignal<boolean>;
+    UseArrayModePaging: _angular_core.WritableSignal<boolean>;
+    CountLabel: _angular_core.InputSignal<string>;
+    Height: _angular_core.InputSignal<string>;
+    MaxHeight: _angular_core.InputSignal<number>;
+    EmptySpaceBackgroundColor: _angular_core.InputSignal<string>;
+    HighCellDensity: _angular_core.InputSignal<boolean>;
+    HeaderHidden: _angular_core.InputSignal<boolean>;
+    BodyHidden: _angular_core.InputSignal<boolean>;
+    ShowLoadingOnBootstrap: _angular_core.InputSignal<boolean>;
+    protected readonly _DefaultAlignment: _angular_core.InputSignal<"Left" | "Center" | "Right">;
+    DefaultAlignment: _angular_core.WritableSignal<"Left" | "Center" | "Right">;
+    protected readonly _TableClass: _angular_core.InputSignal<string>;
+    TableClass: _angular_core.WritableSignal<string>;
+    protected readonly _ContainerClass: _angular_core.InputSignal<string>;
+    ContainerClass: _angular_core.WritableSignal<string>;
+    EsTableHandledSearch: _angular_core.InputSignal<boolean>;
+    SearchThrottle: _angular_core.InputSignal<number>;
+    protected readonly _ColumnsResizable: _angular_core.InputSignal<boolean>;
+    ColumnsResizable: _angular_core.WritableSignal<boolean>;
+    protected readonly _ColumnsPinnable: _angular_core.InputSignal<boolean>;
+    ColumnsPinnable: _angular_core.WritableSignal<boolean>;
+    protected readonly _HiddenColumns: _angular_core.InputSignal<boolean>;
+    HiddenColumns: _angular_core.WritableSignal<boolean>;
+    protected readonly _ColumnsOrdering: _angular_core.InputSignal<boolean>;
+    ColumnsOrdering: _angular_core.WritableSignal<boolean>;
+    protected readonly _Export: _angular_core.InputSignal<boolean>;
+    Export: _angular_core.WritableSignal<boolean>;
+    XLSXExport: _angular_core.InputSignal<boolean>;
+    CSVExport: _angular_core.InputSignal<boolean>;
+    ExportFileName: _angular_core.InputSignal<string>;
+    ExportOnlyVisibleColumns: _angular_core.InputSignal<boolean>;
+    ExportFunction?: (callback: (data: any[], type: Type<any>) => void, format: 'CSV' | 'XLSX') => void;
+    CornerMenuOptions: _angular_core.InputSignal<CornerMenuOption[]>;
+    DynamicOperations: _angular_core.InputSignal<EsTableOperationDefinition[]>;
+    protected readonly _DynamicRowColumnsDefinition: _angular_core.InputSignal<EsTableColumnsDefinition[]>;
+    Hierarchy: _angular_core.InputSignal<boolean>;
+    protected readonly _ParentKey: _angular_core.InputSignal<string>;
+    ParentKey: _angular_core.WritableSignal<string>;
+    protected readonly _OwnKey: _angular_core.InputSignal<string>;
+    OwnKey: _angular_core.WritableSignal<string>;
+    protected readonly _AutoSortHierarchy: _angular_core.InputSignal<boolean>;
+    AutoSortHierarchy: _angular_core.WritableSignal<boolean>;
+    StartsExpanded: _angular_core.InputSignal<boolean>;
+    /** In modalità gerarchica: selezionando un nodo si selezionano tutti i discendenti, e un padre
+     *  risulta selezionato quando tutti i figli lo sono (indeterminato se solo alcuni). */
+    CascadeSelection: _angular_core.InputSignal<boolean>;
+    protected readonly _SavePreferences: _angular_core.InputSignal<boolean>;
+    SavePreferences: _angular_core.WritableSignal<boolean>;
+    /** Nome della tabella: chiave per la persistenza delle preferenze colonne (localStorage) */
+    Name: _angular_core.InputSignal<string>;
+    protected readonly _RowGroupingPagingStyle: _angular_core.InputSignal<"left" | "right">;
+    protected readonly _ShowItemGroupsColumns: _angular_core.InputSignal<boolean>;
+    Editable: _angular_core.InputSignal<boolean>;
+    RangeSelection: _angular_core.InputSignal<boolean>;
+    ItemSourceProperty: _angular_core.InputSignal<string>;
+    HasHeaderGroup: _angular_core.InputSignal<boolean>;
+    HasSecondaryHeaderGroup: _angular_core.InputSignal<boolean>;
+    SearchView: _angular_core.InputSignal<AppSearch<any>>;
+    protected readonly _AutoUpdate: _angular_core.InputSignal<boolean>;
+    onOrderChanged: EventEmitter<AppOrdering>;
+    onSearchRequest: EventEmitter<any>;
+    onSelectionChanged: EventEmitter<ItemsSelection<any>>;
+    onRemoval: EventEmitter<any>;
+    onAbortRemoval: EventEmitter<any>;
+    onModelChange: EventEmitter<EsTableModelChange[]>;
+    onOpenContextMenu: EventEmitter<void>;
+    onCornerAction: EventEmitter<{
+        id: string;
+        estable: any;
+    }>;
+    onDynamicOperation: EventEmitter<{
+        id: string;
+        item: any;
+    }>;
+    globalCheck: _angular_core.ModelSignal<boolean>;
+    autoUpdate: _angular_core.ModelSignal<boolean>;
+    seconds: _angular_core.ModelSignal<string>;
+    researchInProgress: _angular_core.ModelSignal<boolean>;
+    /** Locale usato dal renderer di default (undefined = locale del browser) */
+    locale?: string;
+    /** Modello bindato: AppSearch (viewMode) oppure any[] (arrayMode) */
+    view: _angular_core.WritableSignal<any>;
+    viewMode: _angular_core.WritableSignal<boolean>;
+    arrayMode: _angular_core.WritableSignal<boolean>;
+    firstBind: _angular_core.WritableSignal<boolean>;
+    /** Righe attualmente visualizzate (già paginate/ordinate) */
+    boundSource: _angular_core.WritableSignal<any[]>;
+    /** Colonne derivate dalle direttive `*th`/`*td` */
+    columns: _angular_core.WritableSignal<Est2Column[]>;
+    /** true se la tabella è pilotata dalle direttive (`*th`), false se template semplice */
+    directivesBased: _angular_core.WritableSignal<boolean>;
+    /** true se è attivo il raggruppamento client-side (array mode con colonne `thGroup`) */
+    grouped: _angular_core.WritableSignal<boolean>;
+    /** true se le colonne provengono da `DynamicRowColumnsDefinition` */
+    dynamicMode: _angular_core.WritableSignal<boolean>;
+    /** true se il modello è una view report (`report_columns`) */
+    reportMode: _angular_core.WritableSignal<boolean>;
+    /** Definizione colonne dinamica: risolta dall'input, ma scrivibile (auto-derivata dagli item generici) */
+    DynamicRowColumnsDefinition: _angular_core.WritableSignal<EsTableColumnsDefinition[]>;
+    /** Se true mostra i valori delle colonne di gruppo anche nelle righe-oggetto */
+    ShowItemGroupsColumns: _angular_core.WritableSignal<boolean>;
+    /** Mappa ownKey(string) -> figli diretti, per la modalità gerarchica */
+    private hierChildren;
+    /** Paginazione arrayMode */
+    private arrayPage;
+    /** Ordinamenti attivi (id -> 'ASC'|'DESC') */
+    private orders;
+    /** Header-group: mappa id→direttiva th (inclusi i gruppi) e insieme degli id-gruppo */
+    private hgThById;
+    private hgParentIds;
+    /** Base (solo direttive) di hgThById/hgParentIds, per ri-espandere i Multi a ogni refresh */
+    private baseThById;
+    private baseParentIds;
+    /** Colonne derivate dalle direttive (senza le Multi, che dipendono dai dati) */
+    private directiveColumns;
+    /** Definizioni Multi da srotolare sui dati (`*th Multi:true`) */
+    private multiDefs;
+    hostClass: boolean;
+    get denseClass(): boolean;
+    /** Colonne visibili, con le colonne pinnate spostate in testa (stabile) */
+    visibleColumns: _angular_core.Signal<Est2Column[]>;
+    /** Numero di colonne pinnate visibili */
+    pinnedCount: _angular_core.Signal<number>;
+    /** true se c'è almeno una colonna pinnata */
+    hasPinned: _angular_core.Signal<boolean>;
+    /** Larghezza (px) della colonna di selezione quando sticky */
+    private readonly SEL_STICKY_W;
+    /** Offset `left` (px) di una colonna sticky all'indice `ci` in visibleColumns */
+    pinnedLeftPx(ci: number): number;
+    /** true se la tabella renderizza colonne strutturate (direttive/dinamica/report), non template semplici */
+    usesColumns: _angular_core.Signal<boolean>;
+    /**
+     * Righe di header-group multi-livello, dall'alto (root) verso il basso (padre
+     * immediato). Ricalcolate automaticamente su riordino/visibilità colonne.
+     *
+     * Ogni gruppo si allinea in BASSO: il padre immediato di una colonna sta sempre
+     * nella riga direttamente sopra la colonna; gli antenati più alti salgono. Le
+     * colonne senza gruppo (o con catena più corta) hanno celle-spacer vuote in alto.
+     */
+    headerGroupRows: _angular_core.Signal<Est2HeaderGroupCell[][]>;
+    /** true se ci sono header-group da renderizzare */
+    hasHeaderGroups: _angular_core.Signal<boolean>;
+    /** Numero di elementi totali (per il pager) */
+    totalCount: _angular_core.Signal<any>;
+    /** Pagina corrente per il pager */
+    currentPage: _angular_core.Signal<any>;
+    /** Numero totale di pagine per il pager */
+    totalPages: _angular_core.Signal<any>;
+    private readonly effectiveAllValue;
+    private inited;
+    private onChange;
+    private onTouched;
+    constructor(ngControl: NgControl, cdr: ChangeDetectorRef, hostEl: ElementRef<HTMLElement>, prefService: PreferencesService, defaults: EsTableDefaultable, debugMode: boolean, exportGlobalAcl: string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Risoluzione input: valore esplicito || default di progetto || hard default */
+    private io;
+    ngAfterContentInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: (v: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState?(): void;
+    private changed;
+    private detectMode;
+    private buildColumns;
+    /**
+     * Srotola le colonne `*th Multi:true` sui dati: ogni entry unica
+     * `(header_group, header)` della proprietà-array diventa una colonna sintetica,
+     * e i livelli di `header_group` (separati da ">") alimentano gli header-group.
+     */
+    private buildMultiColumns;
+    /** Costruisce le colonne da una `EsTableColumnsDefinition[]` (modalità dinamica) */
+    private buildDynamicColumns;
+    /** Costruisce le colonne da `report_columns` (modalità report): il valore è preso per indice */
+    private buildReportColumns;
+    /** Sceglie la sorgente delle colonne in base al modello: report → dinamica → direttive */
+    private resolveColumns;
+    /** Visibilità di un'operazione su una riga (gate conditionField/conditionValue, case-insensitive) */
+    operationVisible(op: EsTableOperationDefinition, item: any): boolean;
+    dynamicOperation(item: any, id: string): void;
+    /** Valore di una cella report: `values[indice]` (fallback su accesso diretto) */
+    reportCellValue(item: any, col: Est2Column): any;
+    /** Colore per-cella (fore/back) da `forecolors[i]`/`backcolors[i]`; vale sia report che dinamica */
+    cellColor(item: any, col: Est2Column, kind: 'fore' | 'back'): string | null;
+    /** Valore report formattato (usa il formatter delle aggregazioni: F0-9 / small-long-verylong) */
+    reportCellDisplay(item: any, col: Est2Column): string;
+    /** Costruisce il routerLink di una cella dinamica da `RoutePath` + `RouteParameterProperties` */
+    routerLinkFor(item: any, col: Est2Column): any;
+    private refresh;
+    /** Colonne chiave di raggruppamento, nell'ordine di dichiarazione */
+    private groupColumns;
+    /** Tutte le specifiche di aggregazione, appiattite su tutte le colonne */
+    private aggregationSpecs;
+    private clientSort;
+    orderOf(id: string): 'ASC' | 'DESC' | null;
+    orderIndex(id: string): number;
+    toggleSort(col: Est2Column): void;
+    private syncOrdersFromView;
+    goToPage(p: number): void;
+    changeItemsPerPage(n: number): void;
+    private arraySelection?;
+    /** Ancora per la selezione a range stile Windows (Shift+click) */
+    private selectionAnchor;
+    private currentSelection;
+    /** Righe realmente selezionabili: esclude le righe-gruppo quando il raggruppamento è attivo */
+    private selectableRows;
+    /**
+     * Applica il flag _selected alle righe correnti in base allo stato di selezione.
+     * In modalità **all** una riga è selezionata se NON è tra le esclusioni (vale anche
+     * per le pagine non ancora visitate, dove tutte le righe risultano selezionate).
+     */
+    private applySelectionFlags;
+    /** Ricalcola il conteggio: in modalità **all** è (totale - esclusioni) */
+    private refreshSelectionCount;
+    /** Toggle della selezione di una singola riga (checkbox, click su riga o click destro) */
+    toggleRow(item: any): void;
+    /**
+     * Checkbox globale in testata: seleziona/azzera la **pagina corrente**.
+     * Per estendere la selezione a tutte le pagine si usa `selectEverything()`
+     * (link mostrato nella barra di selezione).
+     */
+    toggleAll(): void;
+    /** Estende la selezione a TUTTI gli elementi, anche quelli delle altre pagine (`selection.all`) */
+    selectEverything(): void;
+    /** Azzera completamente la selezione */
+    clearSelection(): void;
+    private clearSelectionState;
+    private syncGlobalCheck;
+    private emitSelection;
+    /** Click su una riga: espande/collassa un gruppo, oppure gestisce la selezione. */
+    handleRowClick(item: any, event?: MouseEvent): void;
+    /** Selezione a click stile Esplora risorse: plain=solo questo, Ctrl=toggle, Shift=range dall'ancora */
+    private windowsSelect;
+    /** Pipe riusate per il testo di copia (dependency-free) */
+    private fmt;
+    private lk;
+    /** Owner globale del range attivo: solo la tabella "attiva" reagisce a Ctrl+C/V */
+    private static activeRangeOwner;
+    /** Range di celle: ancora (a) + fuoco (f), indici in boundSource() / visibleColumns() */
+    rangeSel: _angular_core.WritableSignal<{
+        a: {
+            r: number;
+            c: number;
+        };
+        f: {
+            r: number;
+            c: number;
+        };
+    }>;
+    /** true durante il trascinamento (per disabilitare la selezione testo via CSS) */
+    rangeDragging: _angular_core.WritableSignal<boolean>;
+    /** Cella attualmente in editing (indici r/c) */
+    editing: _angular_core.WritableSignal<{
+        r: number;
+        c: number;
+    }>;
+    /** Bozza del valore in editing */
+    editDraft: any;
+    /** true se la modalità range è realmente utilizzabile (colonne strutturate, no gruppi/gerarchia) */
+    rangeActive: _angular_core.Signal<boolean>;
+    /** Rettangolo normalizzato del range corrente (o null) */
+    rangeRect: _angular_core.Signal<{
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }>;
+    /** true se la cella (r,c) è dentro il range */
+    inRange(r: number, c: number): boolean;
+    /** Estrae gli indici r/c dal `<td data-r data-c>` più vicino al target */
+    private cellCoords;
+    /** mousedown sulla griglia: apre un nuovo range sulla cella-ancora */
+    onGridMouseDown(event: MouseEvent): void;
+    /** mouseover durante il drag: estende il range (solo se la cella cambia davvero) */
+    onGridMouseOver(event: MouseEvent): void;
+    onDocMouseUp(): void;
+    /** Avviso transitorio mostrato in un piccolo toast (es. incolla incompatibile) */
+    notice: _angular_core.WritableSignal<string>;
+    private noticeTimer;
+    private flashNotice;
+    private clearTextSelection;
+    onDocCopy(event: ClipboardEvent): void;
+    onDocPaste(event: ClipboardEvent): void;
+    /** true se il target dell'evento è un campo di input (copia/incolla nativi) */
+    private isFieldTarget;
+    /** Celle (item+colonna) comprese nel rettangolo di selezione */
+    private rangeCells;
+    private applyPaste;
+    /** Template di editor custom (`*editor`) per una colonna, se fornito dal consumer */
+    editorFor(col: Est2Column): TemplateRef<any> | null;
+    /** Contesto passato ai template `*editor` custom */
+    editorContext(item: any, col: Est2Column): any;
+    isEditing(r: number, c: number): boolean;
+    /** Tipo dell'`<input>` di default in base al tipo di colonna */
+    editorInputType(type: string | null): string;
+    onCellDblClick(item: any, col: Est2Column, r: number, c: number): void;
+    commitEdit(item: any, col: Est2Column): void;
+    cancelEdit(): void;
+    /** Valore grezzo su cui operano editing/paste (gestisce gli oggetti `properties`) */
+    private rawCellValue;
+    /** Scrive un valore GIÀ convertito e restituisce l'eventuale EsTableModelChange */
+    private applyCoerced;
+    /**
+     * Converte una stringa (digitata/incollata) nel tipo della colonna, segnalando
+     * se è compatibile. `ok:false` = valore incompatibile col tipo (es. testo in una
+     * colonna numerica) → chi chiama avvisa e non scrive. Una stringa vuota è sempre
+     * valida e azzera il valore (null).
+     */
+    private coerceValue;
+    /** Parsing numerico tollerante (separatori di migliaia + virgola/punto decimale). `NaN` = non numerico */
+    private toNumber;
+    /** Parsing date tollerante: `dd/MM/yyyy [HH:mm[:ss]]` o formati nativi. `null` = non valida */
+    private parseDateLoose;
+    /** Testo visualizzato di una cella (usato dalla copia) */
+    cellDisplayText(item: any, col: Est2Column): string;
+    /** true se `childKey` è `ancestorKey` stesso o un suo discendente (senza collisioni di prefisso) */
+    private isDescendantKey;
+    /** Espande/collassa un gruppo agendo solo sui flag `_visible` (nessuna ricostruzione) */
+    toggleGroup(group: any): void;
+    /** Item (foglia) appartenenti a un gruppo, a qualsiasi profondità */
+    private groupItems;
+    /** Stato di selezione aggregato di un gruppo, per la sua checkbox */
+    groupSelectionState(group: any): 'all' | 'some' | 'none';
+    /** Seleziona/deseleziona tutti gli item di un gruppo */
+    toggleGroupSelection(group: any): void;
+    /** Testo da mostrare nella cella `col` per una riga-gruppo */
+    groupCellDisplay(group: any, col: Est2Column): string;
+    /** true se la cella di una riga-oggetto va lasciata vuota (colonna di gruppo nascosta) */
+    itemCellHidden(col: Est2Column): boolean;
+    /** Indentazione (px) della cella-chiave in base al livello di gruppo */
+    groupIndent(group: any): number;
+    /** Auto-rileva ownKey/parentKey ('id'/'parentid') se non specificati */
+    private autoDetectHierarchyKeys;
+    /** Costruisce l'albero e applica la selezione; se mancano le chiavi torna la lista invariata */
+    private applyHierarchy;
+    private directChildren;
+    private hierDescendants;
+    /** Selezione in cascata: propaga lo stato al sottoalbero e ricalcola gli antenati */
+    private cascadeSelection;
+    /** Ricostruisce ItemsSelection dai flag `_selected` correnti (usato dalla cascade) */
+    private rebuildSelectionFromFlags;
+    /** Stato indeterminato di una riga-padre in cascade (alcuni discendenti selezionati) */
+    hierarchyIndeterminate(item: any): boolean;
+    /** Espande/collassa un nodo dell'albero */
+    toggleHierarchyNode(item: any): void;
+    /** Indentazione (px) di una riga dell'albero in base al livello */
+    hierarchyIndent(item: any): number;
+    /** Apertura context menu: se la riga non è selezionata la seleziona (solo lei), poi notifica */
+    private onContextMenuOpen;
+    /** Indeterminato: alcune ma non tutte le righe selezionate (per la checkbox globale) */
+    get selectionIndeterminate(): boolean;
+    /** Numero di elementi selezionati (per la barra) */
+    get selectedCount(): number;
+    /** true se c'è almeno un elemento selezionato (mostra la barra) */
+    get hasSelection(): boolean;
+    /** true se sono selezionati TUTTI gli elementi (all senza esclusioni) */
+    get allSelected(): boolean;
+    /** true se ha senso proporre "seleziona tutti": pagina piena, non in all, e ci sono altre pagine */
+    get canSelectEverything(): boolean;
+    canRemove(item: any): boolean;
+    removeItem(item: any): void;
+    abortRemoval(item: any): void;
+    /** Preferenze colonne in memoria (ordine + nascoste). Persistite se `SavePreferences`. */
+    private columnPrefs;
+    /** Applica ordine + visibilità + pin delle preferenze a una lista di colonne appena costruita */
+    private setColumns;
+    /** true una volta caricate le preferenze dal server (evita retrieve multipli) */
+    private prefsLoaded;
+    /**
+     * Chiave di persistenza delle preferenze. Identica all'originale: il `name`
+     * del controllo (ngModel/formControlName). In fallback usa `[Name]`.
+     */
+    private prefsKey;
+    /**
+     * Carica le preferenze dal `PreferencesService` (stesso formato dell'es-table
+     * originale: `{ columns, column_ordering, orders }`). Chiamata una volta sola,
+     * quando esistono già le colonne correnti per poter validare la coerenza.
+     */
+    private ensurePrefsLoaded;
+    private applyLoadedPrefs;
+    /**
+     * Persiste le preferenze correnti nel formato originale
+     * `{ columns (visibili), column_ordering (ordine), orders (ordinamenti) }`.
+     */
+    private saveColumnPrefs;
+    /** Attiva/disattiva il pin di una colonna e persiste (dall'indicatore in testata) */
+    togglePin(col: Est2Column, ev?: Event): void;
+    columnsDialogOpen: _angular_core.WritableSignal<boolean>;
+    /** Lista di lavoro della dialog (copia, per poter annullare) */
+    dialogCols: _angular_core.WritableSignal<{
+        id: string;
+        label: string;
+        visible: boolean;
+        pinned: boolean;
+    }[]>;
+    /** Etichetta leggibile di una colonna (header statico o id) */
+    columnLabel(col: Est2Column): string;
+    openColumnsDialog(): void;
+    closeColumnsDialog(): void;
+    dialogToggle(i: number): void;
+    dialogTogglePin(i: number): void;
+    dialogSetAll(visible: boolean): void;
+    dialogMove(i: number, dir: -1 | 1): void;
+    applyColumnsDialog(): void;
+    resetColumnsDialog(): void;
+    exportMenuOpen: _angular_core.WritableSignal<boolean>;
+    cornerMenuOpen: _angular_core.WritableSignal<boolean>;
+    toggleExportMenu(): void;
+    toggleCornerMenu(): void;
+    /** Chiude i menu a tendina del chrome quando si clicca fuori */
+    onDocClick(): void;
+    /** Colonne da esportare (tutte o solo visibili) e con dato testuale */
+    private exportColumns;
+    /** Righe-dato correnti (esclude righe-gruppo) */
+    private exportRows;
+    /** Matrice [header, ...righe] con i valori visualizzati */
+    private buildExportMatrix;
+    export(format?: 'CSV' | 'XLSX'): void;
+    /** Esporta dati forniti dal consumer (via ExportFunction): li mappa sulle colonne correnti */
+    private exportData;
+    private exportCsv;
+    private exportXlsx;
+    /** Nome file rispettando l'estensione richiesta */
+    private exportFileName;
+    private downloadBlob;
+    cornerAction(id: string): void;
+    rowClass(item: any): string;
+    hasChrome(): boolean;
+    /** Colspan totale per righe a piena larghezza (stato vuoto) */
+    totalColspan(): number;
+    /** Valore grezzo di una proprietà, gestendo gli oggetti "generic" con `properties` */
+    cellValue(item: any, col: Est2Column): any;
+    /** Entry Multi corrispondente a una cella (`item[multiProp][multiIndex]`) */
+    multiCell(item: any, col: Est2Column): any;
+    trackByIndex: (i: number) => number;
+    trackRow: (i: number, item: any) => any;
+    trackCol: (_: number, col: Est2Column) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTable2Component, [{ optional: true; self: true; }, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EsTable2Component, "es-table2", never, { "ContextMenu": { "alias": "ContextMenu"; "required": false; }; "_Selection": { "alias": "Selection"; "required": false; "isSignal": true; }; "SingleSelection": { "alias": "SingleSelection"; "required": false; "isSignal": true; }; "SelectionDisabled": { "alias": "SelectionDisabled"; "required": false; "isSignal": true; }; "_SelectAll": { "alias": "SelectAll"; "required": false; "isSignal": true; }; "_UseSelectionCache": { "alias": "UseSelectionCache"; "required": false; "isSignal": true; }; "_ShiftClick": { "alias": "ShiftClick"; "required": false; "isSignal": true; }; "_OrderByColumn": { "alias": "OrderByColumn"; "required": false; "isSignal": true; }; "MultipleOrderingDirectives": { "alias": "MultipleOrderingDirectives"; "required": false; "isSignal": true; }; "Removal": { "alias": "Removal"; "required": false; "isSignal": true; }; "RemovalCondition": { "alias": "RemovalCondition"; "required": false; "isSignal": true; }; "RowClassAssigner": { "alias": "RowClassAssigner"; "required": false; }; "_HidePaging": { "alias": "HidePaging"; "required": false; "isSignal": true; }; "_HidePagingCount": { "alias": "HidePagingCount"; "required": false; "isSignal": true; }; "_HidePagingButtons": { "alias": "HidePagingButtons"; "required": false; "isSignal": true; }; "_AllSearch": { "alias": "AllSearch"; "required": false; "isSignal": true; }; "_PagingStyle": { "alias": "PagingStyle"; "required": false; "isSignal": true; }; "_ArraymodeItemsPerPage": { "alias": "ArraymodeItemsPerPage"; "required": false; "isSignal": true; }; "_UseArrayModePaging": { "alias": "UseArrayModePaging"; "required": false; "isSignal": true; }; "CountLabel": { "alias": "CountLabel"; "required": false; "isSignal": true; }; "Height": { "alias": "Height"; "required": false; "isSignal": true; }; "MaxHeight": { "alias": "MaxHeight"; "required": false; "isSignal": true; }; "EmptySpaceBackgroundColor": { "alias": "EmptySpaceBackgroundColor"; "required": false; "isSignal": true; }; "HighCellDensity": { "alias": "HighCellDensity"; "required": false; "isSignal": true; }; "HeaderHidden": { "alias": "HeaderHidden"; "required": false; "isSignal": true; }; "BodyHidden": { "alias": "BodyHidden"; "required": false; "isSignal": true; }; "ShowLoadingOnBootstrap": { "alias": "ShowLoadingOnBootstrap"; "required": false; "isSignal": true; }; "_DefaultAlignment": { "alias": "DefaultAlignment"; "required": false; "isSignal": true; }; "_TableClass": { "alias": "TableClass"; "required": false; "isSignal": true; }; "_ContainerClass": { "alias": "ContainerClass"; "required": false; "isSignal": true; }; "EsTableHandledSearch": { "alias": "EsTableHandledSearch"; "required": false; "isSignal": true; }; "SearchThrottle": { "alias": "SearchThrottle"; "required": false; "isSignal": true; }; "_ColumnsResizable": { "alias": "ColumnsResizable"; "required": false; "isSignal": true; }; "_ColumnsPinnable": { "alias": "ColumnsPinnable"; "required": false; "isSignal": true; }; "_HiddenColumns": { "alias": "HiddenColumns"; "required": false; "isSignal": true; }; "_ColumnsOrdering": { "alias": "ColumnsOrdering"; "required": false; "isSignal": true; }; "_Export": { "alias": "Export"; "required": false; "isSignal": true; }; "XLSXExport": { "alias": "XLSXExport"; "required": false; "isSignal": true; }; "CSVExport": { "alias": "CSVExport"; "required": false; "isSignal": true; }; "ExportFileName": { "alias": "ExportFileName"; "required": false; "isSignal": true; }; "ExportOnlyVisibleColumns": { "alias": "ExportOnlyVisibleColumns"; "required": false; "isSignal": true; }; "ExportFunction": { "alias": "ExportFunction"; "required": false; }; "CornerMenuOptions": { "alias": "CornerMenuOptions"; "required": false; "isSignal": true; }; "DynamicOperations": { "alias": "DynamicOperations"; "required": false; "isSignal": true; }; "_DynamicRowColumnsDefinition": { "alias": "DynamicRowColumnsDefinition"; "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; }; "CascadeSelection": { "alias": "CascadeSelection"; "required": false; "isSignal": true; }; "_SavePreferences": { "alias": "SavePreferences"; "required": false; "isSignal": true; }; "Name": { "alias": "Name"; "required": false; "isSignal": true; }; "_RowGroupingPagingStyle": { "alias": "RowGroupingPagingStyle"; "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; }; "ItemSourceProperty": { "alias": "ItemSourceProperty"; "required": false; "isSignal": true; }; "HasHeaderGroup": { "alias": "HasHeaderGroup"; "required": false; "isSignal": true; }; "HasSecondaryHeaderGroup": { "alias": "HasSecondaryHeaderGroup"; "required": false; "isSignal": true; }; "SearchView": { "alias": "SearchView"; "required": false; "isSignal": true; }; "_AutoUpdate": { "alias": "AutoUpdate"; "required": false; "isSignal": true; }; "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; }; "locale": { "alias": "locale"; "required": false; }; }, { "onOrderChanged": "onOrderChanged"; "onSearchRequest": "onSearchRequest"; "onSelectionChanged": "onSelectionChanged"; "onRemoval": "onRemoval"; "onAbortRemoval": "onAbortRemoval"; "onModelChange": "onModelChange"; "onOpenContextMenu": "onOpenContextMenu"; "onCornerAction": "onCornerAction"; "onDynamicOperation": "onDynamicOperation"; "globalCheck": "globalCheckChange"; "autoUpdate": "autoUpdateChange"; "seconds": "secondsChange"; "researchInProgress": "researchInProgressChange"; }, ["headerRef", "bodyRef", "thDirectives", "tdDirectives", "editorDirectives"], never, false, never>;
+}
+
 /** Componente rappresentante una Colonna della tabella */
 declare class EsTh {
     private myself;
@@ -2502,10 +3089,76 @@ declare class EstPropInsensitivePipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<EstPropInsensitivePipe, "est_propinsensitive", false>;
 }
 
+/**
+ * Paginatore dell'es-table2.
+ *
+ * Componente di sola presentazione: riceve lo stato di paginazione via input e
+ * notifica le intenzioni dell'utente via output. Non conosce il concetto di
+ * viewMode/arrayMode — la logica di applicazione vive nel componente padre.
+ */
+declare class EsTable2PagerComponent {
+    /** Valore convenzionale di items-per-page che rappresenta "Tutti" */
+    readonly allValue = 999999;
+    page: _angular_core.InputSignal<number>;
+    pages: _angular_core.InputSignal<number>;
+    total: _angular_core.InputSignal<number>;
+    itemsPerPage: _angular_core.InputSignal<number>;
+    countLabel: _angular_core.InputSignal<string>;
+    showCount: _angular_core.InputSignal<boolean>;
+    showButtons: _angular_core.InputSignal<boolean>;
+    showPagingOptions: _angular_core.InputSignal<boolean>;
+    allowAll: _angular_core.InputSignal<boolean>;
+    pageChange: _angular_core.OutputEmitterRef<number>;
+    itemsPerPageChange: _angular_core.OutputEmitterRef<number>;
+    /** Opzioni della select di items-per-page (con eventuale "Tutti") */
+    ippOptions: _angular_core.Signal<number[]>;
+    /** Finestra di pagine visibili con ellissi (1 … n-1 n n+1 … tot) */
+    visiblePages: _angular_core.Signal<{
+        key: string;
+        page: number;
+    }[]>;
+    goto(p: number): void;
+    onIppChange(ev: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EsTable2PagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EsTable2PagerComponent, "es-table2-pager", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "pages": { "alias": "pages"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; "countLabel": { "alias": "countLabel"; "required": false; "isSignal": true; }; "showCount": { "alias": "showCount"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "showPagingOptions": { "alias": "showPagingOptions"; "required": false; "isSignal": true; }; "allowAll": { "alias": "allowAll"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "itemsPerPageChange": "itemsPerPageChange"; }, never, never, false, never>;
+}
+
+/**
+ * Formattazione di presentazione per il renderer di default (celle senza template).
+ * Self-contained (Intl / Date nativi) per non trascinare dipendenze esterne.
+ *
+ * `format` opzionale sovrascrive il default per tipo:
+ *  - numerici  → "F2" = 2 decimali fissi
+ *  - date      → pattern accettato da Intl (fallback a locale corto)
+ */
+declare class Est2FormatPipe implements PipeTransform {
+    transform(value: any, type?: InputType | string | null, format?: string | null, locale?: string): string;
+    private num;
+    private date;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Est2FormatPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<Est2FormatPipe, "est2_format", false>;
+}
+
+/**
+ * Risolve un valore verso il suo `{ id, description }` in una sorgente enum.
+ * Pura: ricalcola solo quando cambiano `value` o `source`.
+ */
+declare class Est2LookupPipe implements PipeTransform {
+    transform(value: unknown, source?: {
+        id: any;
+        description: string;
+    }[] | null): {
+        id: any;
+        description: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Est2LookupPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<Est2LookupPipe, "est2_lookup", 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.ExtensionsModule, typeof i20.ModalModule, typeof i21.BsDropdownModule, typeof i22.ContextMenuModule, typeof i23.DragDropModule, typeof i24.FormsAndValidationsModule, typeof i25.TooltipModule, typeof i26.AccessControlModule, typeof i27.SelectModule], [typeof EsTdDirective, typeof EsThDirective, typeof EsTdEditorDirective, typeof EsTableComponent, typeof EsTablePagerComponent, typeof ThTdProvider]>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<EsTableModule, [typeof EsTdDirective, typeof EsThDirective, typeof EsTdEditorDirective, typeof EsTableComponent, typeof EsTablePagerComponent, typeof ThTdProvider, typeof EsTable2Component, typeof EsTh, typeof EsTd, typeof EstFormatPipe, typeof EstLookupPipe, typeof EstRouterLinkPipe, typeof EstRendererPipe, typeof EstEditorPipe, typeof EstPropInsensitivePipe, typeof EsTable2PagerComponent, typeof Est2FormatPipe, typeof Est2LookupPipe], [typeof i19.CommonModule, typeof i20.FormsModule, typeof i21.RouterModule, typeof i22.LocalizationModule, typeof i23.ExtensionsModule, typeof i24.ModalModule, typeof i25.BsDropdownModule, typeof i26.ContextMenuModule, typeof i27.DragDropModule, typeof i28.FormsAndValidationsModule, typeof i29.TooltipModule, typeof i30.AccessControlModule, typeof i31.SelectModule], [typeof EsTdDirective, typeof EsThDirective, typeof EsTdEditorDirective, typeof EsTableComponent, typeof EsTablePagerComponent, typeof ThTdProvider, typeof EsTable2Component]>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<EsTableModule>;
 }
 
@@ -2563,5 +3216,12 @@ 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, EsThDirective, GenericItem, Group, GroupAggregation, GroupFilter, GroupOrAggregation, ItemPropEditableReference, ItemsSelection, ReportColumn, ReportParam, ReportRow, ThTdProvider };
-export type { InputType };
+/** Abilita il logging a console */
+declare const EST2_DEBUG: InjectionToken<boolean>;
+/** Espressione ACL globale che abilita/disabilita l'export */
+declare const EST2_EXPORT_GLOBAL_ACL: InjectionToken<string>;
+/** Valori di default per-progetto degli Input */
+declare const EST2_DEFAULTS: InjectionToken<EsTableDefaultable>;
+
+export { AppOrdering, AppSearch, CornerMenuOption, EST2_DEBUG, EST2_DEFAULTS, EST2_EXPORT_GLOBAL_ACL, EST_DEBUG, EST_DEFAULTS, EST_EXPORT_GLOBAL_ACL, EsTable2Component, EsTableColumnsDefinition, EsTableComponent, EsTableDefaultable, EsTableModelChange, EsTableModule, EsTableModuleConfig, EsTableMultiValue, EsTableOperationDefinition, EsTablePagerComponent, EsTdDirective, EsTdEditorDirective, EsThDirective, GenericItem, Group, GroupAggregation, GroupFilter, GroupOrAggregation, ItemPropEditableReference, ItemsSelection, ReportColumn, ReportParam, ReportRow, ThTdProvider };
+export type { Est2Column, Est2HeaderGroupCell, InputType };