@esfaenza/es-table 11.2.21 → 11.2.22-beta4

package/lib/directives/es_td.directive.d.ts

@@ -1,7 +1,5 @@
 import { TemplateRef } from '@angular/core';
-/**
- * Direttiva per la dichiarazione snella di un EsTd da emettere per ogni elemento, data una colonna
- */
+/** Direttiva per la dichiarazione snella di un EsTd da emettere per ogni elemento, data una colonna */
 export declare class EsTdDirective {
     Template: TemplateRef<any>;
     /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsTdComponent */

package/lib/directives/es_th.directive.d.ts

@@ -1,17 +1,26 @@
 import { TemplateRef } from "@angular/core";
-/**
- * Direttiva per la dichiarazione snella di un EsTh da emettere come header
- */
+import { ThAggregation } from "../domain";
+/** Direttiva per la dichiarazione snella di un EsTh da emettere come header */
 export declare class EsThDirective {
     Template: TemplateRef<any>;
+    /** Variabile interna all'interno della quale viene raccolta la cache delle aggregazioni specificate in thAggregation */
+    _thAggregations: ThAggregation[];
     /** Variabile interna che indica il fatto che questo componente è una direttiva. Serve per disambigualrlo dell'EsThComponent */
     _directive: boolean;
+    /** Variabile interna impostata dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
+    _referenced: boolean;
     /** Id della colonna, dev'essere lo stesso per tutti i **td** relativi */
     th: string;
+    /** Indica se la colonna è pinnata o no */
+    thPinned: boolean;
+    /** Indica le dimensioni che deve avere questa colonna quando viene pinnata, senza questo tutte le colonne mi collasserebbero l'una sull'altra */
+    thPinnedWidth: number;
     /** Indicazione sulla visibilità della colonna */
     thVisible: boolean;
     /** Indica se la colonna è fixed, cioè se non può né essere nascosta, né riposizionata. Solo le prime colonne possono essere Fixed */
     thFixed: boolean;
+    /** Indica che la colonna è sotto ad un raggruppamento padre, con questo nome nel **th** */
+    thParent: string;
     /** Ordinamento attuale della colonna */
     thOrder?: 'DESC' | 'ASC';
     /** Indica se questa colonna è ordinabile o meno */
@@ -22,10 +31,14 @@ export declare class EsThDirective {
     thResizable: boolean;
     /** Classi da applicare all'Header della colonna */
     thClass: string;
+    /** Classi da applicare alle righe quando rappresentano un Gruppo */
+    thGroupClass: string;
     /** Equivalente dell'NgIf sul th */
     thIf: boolean;
-    /** Impostato dall'**EsTable**, per controllare che ci sia almeno un TD che utilizzi quest'header */
-    Referenced: boolean;
+    /** Indica che bisogna fare un raggruppamento su questa colonna */
+    thGroup: boolean;
+    /** Indica che bisogna fare una aggregazione su questa colonna, a fronte di almeno un altra con un raggruppamento */
+    thAggregation: string;
     /**
      * @ignore
      */

package/lib/domain/externals/classes/CornerMenuOption.d.ts

@@ -0,0 +1,7 @@
+/** Indica un'opzione cliccabile nel Corner Menù della tabella (il menù richiamabile dai 3 pallini verticli in alto a destra) */
+export declare class CornerMenuOption {
+    /** Id dell'operazione. I callback relativi verranno effettuati con questo */
+    id: string;
+    /** Descrizione dell'operazione da presentare all'utente */
+    description: string;
+}

package/lib/domain/{classes → externals/classes}/EsTableColumnsDefinition.d.ts

@@ -1,6 +1,4 @@
-/**
- * Classe che identifica una colonna. Utilizzata in modalità "Colonne dinamiche"
- */
+/** Classe che identifica una colonna. Utilizzata in modalità "Colonne dinamiche" */
 export declare class EsTableColumnsDefinition {
     description: string;
     propertyName: string;
@@ -11,6 +9,7 @@ export declare class EsTableColumnsDefinition {
     visible: boolean;
     clss: string;
     orderable: boolean;
+    headerWraps: boolean;
     /**
      * Costruttore
      *
@@ -24,10 +23,9 @@ export declare class EsTableColumnsDefinition {
      * @param {boolean} visible Visibilità o meno della colonna
      * @param {string} clss Classe da applicare sia ai TD che ai TH relativi a questa colonna
      * @param {boolean} orderable Indica se la colonna è ordinabile o no (nel senso ASC / DESC / NONE)
+     * @param {boolean} headerWraps Indica se il testo dell'header dev'essere wrappato all'interno del th. Di default no.
      */
-    constructor(description: string, propertyName: string, routePath?: string, routeParameterProperties?: string[], dataOrder?: 'ASC' | 'DESC', columnOrder?: number, visible?: boolean, clss?: string, orderable?: boolean);
-    /**
-     * Routerlink che verrà generato a runtime basandosi sulle informazioni di **routePath** e **routeParameterProperties**
-     */
+    constructor(description: string, propertyName: string, routePath?: string, routeParameterProperties?: string[], dataOrder?: 'ASC' | 'DESC', columnOrder?: number, visible?: boolean, clss?: string, orderable?: boolean, headerWraps?: boolean);
+    /** Routerlink che verrà generato a runtime basandosi sulle informazioni di **routePath** e **routeParameterProperties** */
     routerLink: any;
 }

package/lib/domain/{classes → externals/classes}/EsTableOperationDefinition.d.ts

@@ -1,6 +1,4 @@
-/**
- * Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella
- */
+/** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
 export declare class EsTableOperationDefinition {
     id: string;
     title: string;

package/lib/domain/externals/classes/appsearch/AppSearch.d.ts

@@ -0,0 +1,67 @@
+import { AppOrdering } from './AppOrdering';
+import { ItemsSelection } from './ItemsSelection';
+import { Group } from './Group';
+import { GroupFilter } from './GroupFilter';
+import { GroupOrAggregation } from './GroupOrAggregation';
+/**
+ * Classe che identifica una ricerca paginata in tutte le sue sfumature (di grigio)
+ */
+export declare class AppSearch<T> {
+    /**
+     * Costruttore che genera un'istanza coi valori di default e impostando **firstsearch** a **true**
+     */
+    constructor();
+    /** Indica se c'è una ricerca in corso */
+    searchinprogress: boolean;
+    /** Indica il numero totale di pagine trovate dalla ricerca. Ogni pagina è una lista di **itemsperpageoverride** oggetti */
+    pages: number;
+    /** Conteggio totale degli oggetti trovati (inclusi quelli in pagine non attualmente selezionate) */
+    objectcount: number;
+    /** Conteggio totale dei gruppi trovati (inclusi quelli in pagine non attualmente selezionate) */
+    groupcount: number;
+    /** Pagina attualmente in visualizzazione */
+    page: number;
+    /** Numero di oggetti da persentare in ogni pagina. Per convenzione si considera valorizzato a 15 se non fornito */
+    itemsperpageoverride: number;
+    /** Lista degli oggetti nella pagina attualmente in visualizzazione */
+    items: T[];
+    /** Dizionario contenente tutti i gruppi paginati  */
+    groups: Group[];
+    /** Lista di colonne per cui ordinare */
+    orders: AppOrdering[];
+    /** Lista di colonne da visualizzare */
+    columns: string[];
+    /** Lista di colonne nell'ordine corretto */
+    column_ordering: string[];
+    /** Indica se la ricerca era salvata. Qualora fosse questo il caso, al caricamento l'es-table si occuperà di ri-effettuare la ricerca ed aggiornare il modello */
+    savedstate: boolean;
+    /** Indica se bisogna ancora effettuare la prima ricerca */
+    firstsearch: boolean;
+    /**
+     * Oggetto che indica la selezione corrente.
+     *
+     * Se **all** è **true** vuole dire che è tutto selezionato ed eventualmente ci sono delle esclusioni (**exclusions**)
+     * Se **all** è **false** vuol dire che sono selezionati **item** specifici
+     *
+     * In base all'Input **UseSelectionCache** le proprietà **exclusions** e **items** fanno riferimento o alla pagina corrente (se **false**)
+     * o all'intera ricerca (se **true**)
+     */
+    selection: ItemsSelection<T>;
+    /**
+     * Indica che la ricerca è stata richiesta dall'estable. Questa variabile NON deve essere toccata. È gestita al 100% dall'es-table.
+     *
+     * L'unica cosa che serve è che nel modello lato C# sia presente in modo da non perderla durante la serializzazione
+     */
+    internalsearchrequest: boolean;
+    /** Raggruppamenti da fare per questa query. Se impostato e non ci sono **filtergroup** mi aspetto di ricevere oggetti nel campo **groups** */
+    groupings: GroupOrAggregation[];
+    /**
+     * Filtro da applicare ai gruppi. Qualora il numero di filtri qui fosse uguale al numero di raggruppamenti mi inizio ad apettare di ricevere oggetti
+     * sul campo **items**, in caso contrario mi aspetto di ricevere o i gruppi nel campo **groups** o l'N-esimo livello dei gruppi
+     */
+    requestedgroups: GroupFilter[];
+    /**
+     * Permette di resettare questo oggetto ai valori di default
+     */
+    reset(): void;
+}

package/lib/domain/externals/classes/appsearch/GenericItem.d.ts

@@ -0,0 +1,13 @@
+/** Classe che definisce un oggetto generico come lista di proprietà-valore */
+export declare class GenericItem {
+    /** @ignore */
+    constructor();
+    /** Dizionario delle proprietà dell'oggeto con il loro valore */
+    properties: Record<string, string>;
+    /** Indica se l'oggetto in questione è selezionato o meno */
+    _selected: boolean;
+    /** Viene valorizzato da un eventuale **RowClassAssigner** (o automaticamente se in modalità gerarchica) e serve applicare stili particolari alla intera riga */
+    _rowClass: string;
+    /** Hash dell'oggetto per generare i contesti di bind all'interno dell'es-table (vedere eventualmente l'implementazione specifica) */
+    _hash: string;
+}

package/lib/domain/externals/classes/appsearch/Group.d.ts

@@ -0,0 +1,17 @@
+import { GroupAggregation } from "./GroupAggregation";
+/** Classe che rappresenta un Gruppo con le proprie aggregazioni */
+export declare class Group {
+    column: string;
+    count: number;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna raggruppata
+     * @param {number} count Numero di elementi raggruppati sotto questa colonna
+     * @param {string} value Valore del Gruppo
+     */
+    constructor(column: string, count: number, value: string);
+    /** Aggregazioni presenti su questo gruppo, valide per tutte le altre colonne (non a loro volta gruppate) */
+    aggregations: GroupAggregation[];
+}

package/lib/domain/externals/classes/appsearch/GroupAggregation.d.ts

@@ -0,0 +1,14 @@
+/** Classe che rappresenta un'aggregazione */
+export declare class GroupAggregation {
+    column: string;
+    aggregation: 'min' | 'max' | 'sum';
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna aggregata
+     * @param {'min' | 'max' | 'sum' } aggregation Aggregazione da effettuare su questa colonna
+     * @param {string} value Valore dell'aggregazione
+     */
+    constructor(column: string, aggregation: 'min' | 'max' | 'sum', value: string);
+}

package/lib/domain/externals/classes/appsearch/GroupFilter.d.ts

@@ -0,0 +1,12 @@
+/** Classe che rappresenta un filtro su un gruppo */
+export declare class GroupFilter {
+    column: string;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column ID della colonna gruppata per cui si richiede di filtrare
+     * @param {string} value Valore del gruppo su questa **column** per cui si richiede di filtrare
+     */
+    constructor(column: string, value: string);
+}

package/lib/domain/externals/classes/appsearch/GroupOrAggregation.d.ts

@@ -0,0 +1,14 @@
+/** Classe che rappresenta o un gruppo o una aggregazione su una colonna. Usata solo internamente */
+export declare class GroupOrAggregation {
+    column: string;
+    aggregation?: 'min' | 'max' | 'sum';
+    datatype?: 'string' | 'date' | 'number';
+    /**
+     * Costruttore
+     *
+     * @param {string} column Colonna su cui è presente o un gruppo o un'aggregazione
+     * @param {'min' | 'max' | 'sum' } aggregation Aggregazione presente sulla **column**. Se questo campo è nullo significa che è un gruppo.
+     * @param {'string' | 'date' | 'number'} datatype Tipo di dati contenuto nella colonna **column** se non c'è alcuna aggregazione è inutile, pertanto non sarà valorizzato
+     */
+    constructor(column: string, aggregation?: 'min' | 'max' | 'sum', datatype?: 'string' | 'date' | 'number');
+}

package/lib/domain/externals/classes/appsearch/ItemsSelection.d.ts

@@ -0,0 +1,22 @@
+import { Group } from "../..";
+/** Identifica una selezione applicabile agli oggetti presentati in una tabella */
+export declare class ItemsSelection<T> {
+    /**
+     * Costruttore
+     *
+     * @param {T[]} selected Oggetti da considerare selezionati
+     */
+    constructor(selected: T[]);
+    /** Conteggio degli oggetti selezionati */
+    count: number;
+    /** Se **all** è **false** indica gli elementi da includere, altrimenti è insensato */
+    items: T[];
+    /** Se **all** è **false** indica i gruppi, altrimenti è insensato */
+    groups: Group[];
+    /** Indica se tutti gli elementi sono da considerarsi selezionati (anche quelli di altre pagine) */
+    all: boolean;
+    /** Se **all** è **true**, indica gli elementi da escludere, altrimenti è insensato */
+    exclusions: T[];
+    /** Se **all** è **true**, indica i gruppi da escludere, altrimenti è insensato */
+    group_exclusions: Group[];
+}

package/lib/domain/externals/classes/report/ReportColumn.d.ts

@@ -0,0 +1,15 @@
+/** Classe che rappresenta una colonna di un report */
+export declare class ReportColumn {
+    /** Id della colonna */
+    id: string;
+    /** Descrizione della colonna (Header) */
+    description: string;
+    /** Colore in notazione HTML */
+    color: string;
+    /** Tipo di campo contenuto in questa colonna */
+    type: number;
+    /** Sequenza per eventuali ordinamenti */
+    seq: number;
+    /** Ordinamento dei dati presentati */
+    order: string;
+}

package/lib/domain/externals/classes/report/ReportDefinition.d.ts

@@ -0,0 +1,24 @@
+import { ReportParam, ReportOrder, ReportResult } from "../..";
+/** Definizione generica di un report che può o no disporre di paginazione/export e la cui richiesta è basata su uno o più parametri */
+export declare class ReportDefinition {
+    /** Codice report */
+    id: string;
+    /** Descrizione report */
+    description: string;
+    /** Indica se questo report dispone/può disporre di paginazione */
+    pagingavailable: boolean;
+    /** Pagina attualmente in visualizzazione */
+    page: number;
+    /** Numero massimo di pagine */
+    pages: number;
+    /** Numero di elementi per pagina, si consideri 15 in caso questo parametro non fosse assegnato */
+    itemsperpageoverride: number;
+    /** Formato di Export disponibile */
+    expformat: string;
+    /** Parametri del report */
+    pars: ReportParam[];
+    /** Informazioni di ordinamento dati delle colonne relative al report */
+    orders: ReportOrder[];
+    /** Risultato della ricerca di un report, equivalente all'**items** dell'AppSearch e nel formato specifico dei report */
+    result: ReportResult;
+}

package/lib/domain/externals/classes/report/ReportOrder.d.ts

@@ -0,0 +1,7 @@
+/** Classe che identifica una direttiva di ordinamento per un report */
+export declare class ReportOrder {
+    /** Ordine */
+    order: string;
+    /** Colonna relativa */
+    column: string;
+}

package/lib/domain/externals/classes/report/ReportParam.d.ts

@@ -0,0 +1,40 @@
+/** Classe che identifica un parametro generico per un report */
+export declare class ReportParam {
+    /** Codice del parametro */
+    id: string;
+    /** Descrizione del parametro */
+    description: string;
+    /** Tipo enumerabile del parametro (qualora fosse un dizionario di valori) */
+    enumtype: string;
+    /** Colonna relativa e questo parametro */
+    column: string;
+    /** Tipo del dizionario */
+    dictype: string;
+    /** Sequenza del parametro per ordinarlo logicamente rispetto agli altri */
+    seq: number;
+    /** Typecode C# della tipologia di parametro */
+    typecode: number;
+    /** Indica se i parametro è richiesto o meno */
+    required: boolean;
+    /** Valore del parametro, offerto sia come valore di default o in alternativa riempito lato UI */
+    value: any;
+    /** Indica se questo parametro si basa su un enum. Se questa proprietà è true mi aspetto che almeno **enumtype** sia valorizzato */
+    isenum: boolean;
+    /** Indica se questo parametro si basa su un dizionario. Se questa proprietà è true mi aspetto che almeno **dictype** sia valorizzato */
+    isdictionary: boolean;
+    /** Indica se il parametro è di tipo data */
+    isdate: boolean;
+    /** Indica se il parametro è di tipo boolean */
+    isboolean: boolean;
+    /** Indica un filtro da applicare nei confronti del Backend qualora si vogliano caricare solo le possibilità logicamente accettabili per questo parametro */
+    dictionaryfilter: string;
+    /** Valori disponibili per questo parametro, da valorizzare in caso **enumtype** o **dictype** fossero valorizzati */
+    availablevalues: {
+        id: string;
+        description: string;
+    }[];
+    /** Tipologia lato "typescript" di questo parametro, dev'essere sempre logicamente congruente al **typecode** */
+    type: "string" | "number" | "date" | "boolean";
+    /** Eventuale pattern di validazione per questo parametro */
+    pattern: string;
+}

package/lib/domain/externals/classes/report/ReportResult.d.ts

@@ -0,0 +1,12 @@
+import { ReportColumn, ReportRow } from "../..";
+/** Classe che rappresenta una lista di oggetti generati da un report */
+export declare class ReportResult {
+    /** Numero di oggetti generati */
+    count: number;
+    /** Se il report è vuoto o no (essenzialmente è un **count == 0**) */
+    empty: boolean;
+    /** Colonne del report (indicazione delle varie proprietà da mostrare e Header con cui mostrarli) */
+    columns: ReportColumn[];
+    /** Righe del report: 1 riga = 1 oggetto */
+    rows: ReportRow[];
+}

package/lib/domain/externals/classes/report/ReportRow.d.ts

@@ -0,0 +1,5 @@
+/** Classe che rappresenta i valori delle proprietà di un oggetto Report */
+export declare class ReportRow {
+    /** Valori dell'oggetto in ordine sequenziale */
+    values: string[];
+}

package/lib/domain/externals/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./classes/appsearch/AppOrdering";
+export * from "./classes/appsearch/AppSearch";
+export * from "./classes/EsTableColumnsDefinition";
+export * from "./classes/appsearch/GenericItem";
+export * from "./classes/CornerMenuOption";
+export * from "./classes/report/ReportDefinition";
+export * from "./classes/report/ReportOrder";
+export * from "./classes/report/ReportColumn";
+export * from "./classes/report/ReportResult";
+export * from "./classes/report/ReportRow";
+export * from "./classes/report/ReportParam";
+export * from "./classes/EsTableOperationDefinition";
+export * from "./classes/appsearch/ItemsSelection";
+export * from "./classes/appsearch/Group";
+export * from "./classes/appsearch/GroupAggregation";
+export * from "./classes/appsearch/GroupFilter";
+export * from "./classes/appsearch/GroupOrAggregation";

package/lib/domain/index.d.ts

@@ -1,15 +1,2 @@
-export * from "./classes/AppOrdering";
-export * from "./classes/AppSearch";
-export * from "./classes/EsTableColumnsDefinition";
-export * from "./classes/GenericItem";
-export * from "./classes/IAppSearch";
-export * from "./classes/CornerMenuOption";
-export * from "./classes/ReportDefinition";
-export * from "./classes/ReportOrder";
-export * from "./classes/ReportColumn";
-export * from "./classes/ReportResult";
-export * from "./classes/ReportRow";
-export * from "./classes/ReportParam";
-export * from "./classes/EsTableOperationDefinition";
-export * from "./classes/EsTableColumn";
-export * from "./classes/ItemsSelection";
+export * from "./externals";
+export * from "./internals";

package/lib/domain/internals/classes/CacheTriptic.d.ts

@@ -0,0 +1,14 @@
+/** Rappresenta un trittico formato da un array e due cache relative a tale array per un accesso estremamente veloce per tutte le operazioni del caso */
+export declare class CacheTriptic {
+    cache: Map<string, any>;
+    index_cache: Map<string, number>;
+    array: any[];
+    /**
+     * Costruttore
+     *
+     * @param {Map<string, any>} cache Cache Chiave-Oggetto
+     * @param {Map<string, number>} index_cache Cache Indice-Oggetto
+     * @param {any[]} array Array contenente gli oggetti
+     */
+    constructor(cache: Map<string, any>, index_cache: Map<string, number>, array: any[]);
+}

package/lib/domain/{classes → internals/classes}/EsTableColumn.d.ts

@@ -1,12 +1,12 @@
 import { TemplateRef } from "@angular/core";
-/**
- * Definizione di una colonna
- */
+/** Definizione di una colonna, utilizzato nella dialog che permette di modificare le posizioni e le visibilità */
 export declare class EsTableColumn {
     id: string;
     description: string;
     visible: boolean;
     fixed: boolean;
+    pinned: boolean;
+    pinnedWidth: number;
     template: TemplateRef<any>;
     /**
      * Costruttore
@@ -15,7 +15,9 @@ export declare class EsTableColumn {
      * @param {string} description Descrizione (Header)
      * @param {boolean} visible Indica se di default mostrarla o meno
      * @param {boolean} fixed Indica se è una colonna fixed
+     * @param {boolean} pinned Indica se è una colonna pinnata
+     * @param {number} pinnedWidth Indica la dimensione da assegnare a questa colonna quando è pinnata
      * @param {TemplateRef<any>} template Indica il template da usare per mostrare il testo dell'Header
      */
-    constructor(id: string, description: string, visible: boolean, fixed: boolean, template: TemplateRef<any>);
+    constructor(id: string, description: string, visible: boolean, fixed: boolean, pinned: boolean, pinnedWidth: number, template: TemplateRef<any>);
 }

package/lib/domain/internals/classes/GroupPager.d.ts

@@ -0,0 +1,22 @@
+import { AppSearch, GroupRouteFragment } from "../..";
+/** Classe che rappresenta un separatore da inserire fra gli oggetti dell'es-table per le operazioni di paginazione dei raggruppamenti per riga */
+export declare class GroupPager {
+    _grouplevel: number;
+    _thisRoute: GroupRouteFragment[];
+    _parent: string;
+    view: AppSearch<any>;
+    searches: 'groups' | 'items';
+    /**
+     * Costruttore
+     *
+     * @param {number} groupLevel Livello del gruppo a cui questo separatore fa riferimento
+     * @param {string} parentKey Chiave del gruppo parent se esiste
+     * @param {AppSearch<any>} view Vista di ricerca collegata a questo elemento
+     * @param {'groups' | 'items'} searches Indica che cosa cerca questo separatore, se sottogruppi o oggetti
+     */
+    constructor(_grouplevel: number, _thisRoute: GroupRouteFragment[], _parent: string, view: AppSearch<any>, searches: 'groups' | 'items');
+    /** Indica che è un separatore, sempre impostato a **true** */
+    _sep: boolean;
+    /** Array dei pulsanti da collegare lato interfaccia per le paginazione */
+    buttons: any[];
+}

package/lib/domain/internals/classes/GroupRouteFragment.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Classe che rappresenta un singolo frammento di route di un elemento gruppo o non. Un array di questi indica tutte le colonne di gruppo con i loro valori
+ * per arrivare ad una ricerca su sottogruppi o elementi relativi
+ */
+export declare class GroupRouteFragment {
+    column: string;
+    value: string;
+    /**
+     * Costruttore
+     *
+     * @param {string} column Colonna di raggruppamento
+     * @param {string} value Valore della colonna di raggruppamento
+     */
+    constructor(column: string, value: string);
+}

package/lib/domain/internals/classes/ThAggregation.d.ts

@@ -0,0 +1,14 @@
+/** Classe rappresentante una singola aggregazione effettuata su una colonna */
+export declare class ThAggregation {
+    func: 'min' | 'max' | 'sum';
+    format: string;
+    match: string;
+    /**
+     * Costruttore
+     *
+     * @param {'min' | 'max' | 'sum'} func Funzione di aggergazione, può essere **min**, **max** o **sum**
+     * @param {string} format Formato richiesto per il valore dell'aggregazione
+     * @param {string} match Match intero del pezzo di testo da cui si è estrapolata l'aggregazione, da rimpiazzare col valore calcolato
+     */
+    constructor(func: 'min' | 'max' | 'sum', format: string, match: string);
+}

package/lib/domain/internals/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./classes/CacheTriptic";
+export * from "./classes/EsTableColumn";
+export * from "./classes/GroupPager";
+export * from "./classes/GroupRouteFragment";
+export * from "./classes/ThAggregation";