@esfaenza/es-charts 19.2.26 → 20.3.0

package/index.d.ts

@@ -1,5 +1,1678 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, AfterViewInit, OnDestroy, OnInit, OnChanges, ElementRef, NgZone, SimpleChanges, Type, ModuleWithProviders, InjectionToken } from '@angular/core';
+import * as am4charts from '@amcharts/amcharts4/charts';
+import { DateService } from '@esfaenza/extensions';
+import { LocalizationService } from '@esfaenza/localizations';
+import * as i9 from '@angular/common';
+
 /**
- * Generated bundle index. Do not edit.
+ * Modello che identifica un limite superiore - inferiore
  */
-/// <amd-module name="@esfaenza/es-charts" />
-export * from './public-api';
+declare class Limit {
+    upper?: number;
+    upperlabel?: string;
+    uppercolor?: string;
+    lower?: number;
+    lowerlabel?: string;
+    lowercolor?: string;
+    fillColor: string;
+    /** @ignore */
+    constructor(upper?: number, upperlabel?: string, uppercolor?: string, lower?: number, lowerlabel?: string, lowercolor?: string, fillColor?: string);
+}
+
+/**
+ * Modello che identifica la coppia Data-Valore
+ */
+declare class DateValue {
+    d: Date;
+    v: number;
+    /** @ignore */
+    constructor(d: Date, v: number);
+}
+
+/**
+ * Classe che identifica un intervallo di tempo fra un dato e l'altro
+ */
+declare class BaseInterval {
+    /**
+     * Numero di unità
+     */
+    count: number;
+    /**
+     * Tipo di unità
+     */
+    timeunit: "millisecond" | "second" | "minute" | "hour" | "day" | "week" | "month" | "year";
+}
+
+/**
+ * Modello che identifica una serie a Linea
+ */
+declare class LineSerie {
+    name: string;
+    values: DateValue[];
+    interval?: BaseInterval;
+    color?: string;
+    uom?: string;
+    fill?: boolean;
+    stacked?: boolean;
+    hidden?: boolean;
+    /**
+     * Costruttore
+     *
+     * @param {string} name Nome della serie
+     * @param {DateValue[]} values Valori della serie
+     * @param {BaseInterval} interval Intervallo della serie. Viene utilizzato per gestire Gap e date in Istante Finale
+     * @param {string} color Colore della serie, verrà usato sia per la linea base che eventualmente per il riempimento (in caso si utilizzi l'Input **Fill** nel grafico)
+     * @param {string} uom Unità di misura da presentare nell'asse delle Y
+     * @param {boolean} fill Override della proprietà **Fill** del grafico, specifico per ogni serie
+     * @param {boolean} stacked Override della proprietà **Stacked** del grafico, specifico per ogni serie
+     * @param {boolean} hidden Indica se la serie deve partire nascosta di default
+     */
+    constructor(name: string, values: DateValue[], interval?: BaseInterval, color?: string, uom?: string, fill?: boolean, stacked?: boolean, hidden?: boolean);
+}
+
+/**
+ * Dati relativi a un grafico di tipo LineChart
+ */
+declare class LineChartData {
+    series: LineSerie[];
+    limit?: Limit | Limit[];
+    /**
+     * Costruttore
+     *
+     * @param {LineSerie[]} series Lista di serie da graficare
+     * @param {{upper: lower}}
+     */
+    constructor(series?: LineSerie[], limit?: Limit | Limit[]);
+}
+
+/**
+ * Modello che identifica la coppia Chiave-Valore con in aggiunta il Colore da usare per la serie che verrà creata da questo modello
+ */
+declare class KeyValueColor {
+    k: string;
+    v: number;
+    c?: string;
+    t?: string;
+    /** @ignore */
+    constructor(k: string, v: number, c?: string, t?: string);
+}
+
+/**
+ * Dati relativi a un grafico di tipo PieChart
+ */
+declare class PieChartData {
+    values: KeyValueColor[];
+    /**
+     * Costruttore
+     *
+     * @param {KeyValueColor[]} values Lista di Chiave-Valore-Colore che rappresentano ognuno uno spicchio del grafico a torta
+     */
+    constructor(values?: KeyValueColor[]);
+}
+
+/**
+ * Dati relativi a un grafico di tipo VerticalChart
+ */
+declare class VerticalChartData {
+    values: KeyValueColor[];
+    /**
+     * Costruttore
+     *
+     * @param {KeyValueColor[]} values Lista di Chiave-Valore-Colore che rappresentano ognuno una colonna
+     */
+    constructor(values?: KeyValueColor[]);
+}
+
+/**
+ * Modello che identifica la coppia Chiave-Valore
+ */
+declare class KeyValue {
+    k: string;
+    v: number;
+    /** @ignore */
+    constructor(k: string, v: number);
+}
+
+/**
+ * Dati relativi a un grafico di tipo Vertical2DChart
+ */
+declare class Vertical2DChartData {
+    groups: {
+        name: string;
+        values: KeyValue[];
+        uom?: string;
+    }[];
+    colorinfos?: {
+        color: string;
+    }[];
+    /**
+     * Costruttore
+     *
+     * @param {{ name: string; values: KeyValue[];, uom: string }[]} groups Gruppi di valori raggruppati per nome
+     * @param {{ color: string }[]} colorinfos Lista dei colori da utilizzare. Vanno a sovrascrivere quelli di default di amcharts
+     */
+    constructor(groups?: {
+        name: string;
+        values: KeyValue[];
+        uom?: string;
+    }[], colorinfos?: {
+        color: string;
+    }[]);
+}
+
+/**
+ * Dati relativi a un grafico di tipo VerticalStackedChart
+ */
+declare class VerticalStackedChartData {
+    groups: {
+        name: string;
+        values: KeyValue[];
+        uom?: string;
+    }[];
+    /**
+     * Costruttore
+     *
+     * @param {{ name: string; values: KeyValue[], uom: string }[]} groups Gruppi di valori raggruppati per nome
+     */
+    constructor(groups?: {
+        name: string;
+        values: KeyValue[];
+        uom?: string;
+    }[]);
+}
+
+/**
+ * Dati relativi a un grafico di tipo AreaChart
+ */
+declare class AreaChartData {
+    groups: {
+        name: Date;
+        values: KeyValue[];
+    }[];
+    interval?: BaseInterval;
+    /**
+     * Costruttore
+     *
+     * @param {{ name: Date; values: KeyValue[]; }[]} groups Gruppi di valori raggruppati per data
+     * @param {BaseInterval} interval Intervallo della serie. Viene utilizzato per gestire eventuali Gap
+     */
+    constructor(groups?: {
+        name: Date;
+        values: KeyValue[];
+    }[], interval?: BaseInterval);
+}
+
+/**
+ * Interfaccia per l'implementazione di un adapter che possa essere utilizzato al posto del BaseAdapter qualora servisse
+ */
+interface IBaseAdapter {
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per gli Area Chart
+     */
+    adaptDataForAreaChart(anyData: any): AreaChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Line Chart
+     */
+    adaptDataForLineChart(anyData: any): LineChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Pie Chart
+     */
+    adaptDataForPieChart(anyData: any): PieChartData;
+    /**
+    * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Vertical Chart
+    */
+    adaptDataForVerticalChart(anyData: any): VerticalChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Vertical Chart a due dimensioni
+     */
+    adaptDataForVertical2DChart(anyData: any): Vertical2DChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Vertical Chart sovrapposti
+     */
+    adaptDataForVerticalStackedChart(anyData: any): VerticalStackedChartData;
+}
+
+/**
+ * Adapter Base da reimplementare per trasformare i dati da una libreria di grafici a questa per evitare di riscrivere tutto il codice di
+ * generazione delle serie in caso si fossero usati grafici di altre librerie
+ */
+declare class BaseAdapter implements IBaseAdapter {
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per gli Area Chart
+     */
+    adaptDataForAreaChart(anyData: any): AreaChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Line Chart
+     */
+    adaptDataForLineChart(anyData: any): LineChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Line Chart
+     */
+    adaptDataForPieChart(anyData: any): PieChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Vertical Chart
+     */
+    adaptDataForVerticalChart(anyData: any): VerticalChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Vertical Chart a due dimensioni
+     */
+    adaptDataForVertical2DChart(anyData: any): Vertical2DChartData;
+    /**
+     * Trasformatore dai dati della libreria vecchia ai dati della libreria nuova per i Vertical Chart sovrapposti
+     */
+    adaptDataForVerticalStackedChart(anyData: any): VerticalStackedChartData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseAdapter>;
+}
+
+/**
+ * Classe che identifica le informazioni di Padding per la Legenda
+ */
+declare class LegendPad {
+    /**
+     * Padding in alto
+     */
+    top: number;
+    /**
+     * Padding in basso
+     */
+    bottom: number;
+    /**
+     * Padding a sinistra
+     */
+    left: number;
+    /**
+     * Padding a destra
+     */
+    right: number;
+}
+
+/**
+ * Classe che racchiude le impostazioni base bene o male applicabili ad ogni Grafico
+ */
+declare abstract class BaseSettings {
+    /**
+     * Utilizza o no la Timeline
+     */
+    Timeline: boolean;
+    /**
+     * Visualizza o no la Legenda
+     */
+    Legend: boolean;
+    /**
+     * Nome del grafico (identificativo univoco)
+     */
+    Name: string;
+    /**
+     * Titolo dell'asse X
+     */
+    XAxisTitle: string;
+    /**
+     * Titolo dell'asse Y
+     */
+    YAxisTitle: string;
+    /**
+     * Dà evidenza, nell'asse X dei momenti in cui cambia il valore
+     */
+    ShowTicks: boolean;
+    /**
+     * Indica se utilizzare il comportamento di default per i click delle serie sulla Legenda. Mettendo questa variabile a **false**
+     * e collegando l'output **onSeriesClicked** è possibile generare un evento ogni volta che l'utente fa click su una serie della Legenda
+     */
+    HideSeriesOnLabelClick: boolean;
+    /**
+     * Minima distanza nella griglia fra i valori, modifica la quantità di step fra i valori dell'asse X e quindi la granularità dei dati.
+     *
+     * Più piccola è, più valori verranno inseriti nell'asse X
+     */
+    MinGridDistance: number;
+    /**
+     * Indica la posizione della Legenda rispetto al grafico
+     */
+    LegendPosition: "top" | "bottom" | "left" | "right";
+    /**
+     * Cerca di aggiustare i vari step dell'asse X ruotandoli e diminuendone le dimensioni abbastanza per mostrarne il più possibile
+     */
+    AdaptLabelSizeAndOrientation: boolean;
+    /**
+     * Padding da applicare alla Legenda in caso si voglia spostare un po'
+     */
+    LegendPadding: LegendPad;
+    /**
+     * Tema da utilizzare, valido solo per il grafico in questione. Gli altri grafici della pagina possono avere stili diversi.
+     *
+     * Essendo i temi caricati in maniera asincrona in base all'utilizzo utilizzarne tanti diversi in un'unica pagina potrebbe rallentare il primo caricamento
+     */
+    Theme: 'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none';
+    /**
+     * Locale del singolo grafico
+     */
+    Locale: string;
+    /**
+     * Utilizzo o meno delle animazioni. Senza animazioni il grafico è leggermente più performante, specialmente all'aumentare dei punti nella serie
+     */
+    Animations: boolean;
+}
+
+/**
+ * Classe che presenta le impostazioni di generazione per i grafici di tipo AreaChart
+ */
+declare class AreaChartSettings extends BaseSettings {
+    /**
+     * @ignore
+     */
+    constructor();
+}
+
+/**
+ * Classe che presenta le impostazioni di generazione per i grafici di tipo LineChart
+ */
+declare class LineChartSettings extends BaseSettings {
+    /**
+     * @ignore
+     */
+    constructor();
+    /**
+     * Indica se sono permessi dei Gap fra un valore e l'altro.
+     *
+     * Normalmente quando ci sono dei buchi l'ultimo datapoint del buco viene collegato direttamente al primo datapoint disponibile.
+     *
+     * Impostando questo Input a true invece, posto di aver assegnato la variabile **interval** della classe **LineChartData**, è possibile
+     * far apparire il blocco di dati mancanti come un buco vero e proprio, senza alcun collegamento fra i due datapoint estremi
+     */
+    AllowGaps: boolean;
+    /**
+     * Soglia per controllare oltre che numero di datapoint il grafico deve iniziare ad effettuare raggruppamenti considerando l'Input **DataGroupBucketSize**
+     */
+    DataGroupingThreshold: number;
+    /**
+     * Indica il numero massimo di datapoint visualizzabile in una singola vista del grafico. L'eccedenza viene raggruppata e verrà mostrata sullo zoom.
+     *
+     * ATTENZIONE: Utilizzando il sistema di default di raggruppamento di am-charts si rischia di tagliare via pezzi da serie molto ondulate
+     * in quanto il comportamento di default è quello di eliminare i datapoint che non ci stanno, non di interpolarli
+     */
+    DataGroupBucketSize: number;
+    /**
+     * Indica se la curva deve collegare direttamente un datapoint all'altro o se deve fare degli step
+     */
+    Step: boolean;
+    /**
+     * Indica le dimnsioni, in pixel della linea del grafico
+     */
+    StrokeSize: number;
+    /**
+     * Input che permette di rielaborare i dati del grafico per generare un solo Dataset
+     *
+     * Viene utilizzato semplicemente per dare un tooltip molto più bello/avanzato sullo scorrimentodel cursore all'interno del grafico
+     */
+    MergeDatasets: boolean;
+    /**
+     * Indica se le date che arrivano all'asse X devono essere considerate "Istante finale" e aggiustate di conseguenza.
+     * Se non è valorizzata la variabile **interval** della classe **LineChartData** non ha alcun effetto
+     *
+     * Ad esempio, la data 16/07/2021 con intervallo orario verrebbe trasformata in 15/07/2021 24:00:00 (Ovviamente è utilizzato solo lato presentazione)
+     */
+    FinalInstants: boolean;
+    /**
+     * Indica se effettuare il Fill della serie in modo da non vedere solo la linea ma proprio l'area sottessa completamente colorata
+     */
+    Fill: boolean;
+    /**
+    * Indica se effettuare lo Stack della serie in modo da vedere tutte le linee una sopra l'altra. Implicitamente include anche il **Fill**
+    */
+    Stacked: boolean;
+    /**
+     * Gestisce il minimo dell'asse Y
+     */
+    Min: number;
+    /**
+     * Gestisce il massimo dell'asse Y
+     */
+    Max: number;
+}
+
+/**
+ * Classe che presenta le impostazioni di generazione per i grafici di tipo PieChart
+ */
+declare class PieChartSettings extends BaseSettings {
+    /**
+     * Indica se apparire in modalità 3D o 2D
+     */
+    Mode3D: boolean;
+    /**
+     * Indica se mostrare o meno le serie con percentuale a 0
+     */
+    HideZeroes: boolean;
+    /**
+     * Percentuale dell'altezza del grafico che viene utilizzata per creare il buco all'interno della ciambella **wink** **wink**
+     */
+    DonutRadiusPercentage: number;
+    /**
+     * Indica se wrappare le label che non stanno nel contenitore
+     */
+    LabelsWrap: boolean;
+    /**
+     * Indica se troncare le label che non stanno nel contenitore
+     */
+    LabelsTruncate: boolean;
+    /**
+     * Indica la dimensione massima che possono assumere le label
+     */
+    LabelsWidth: number;
+    /**
+     * Indica se mostrare o meno le labels
+     */
+    LabelsVisible: boolean;
+    /**
+     * Customizzazioni sulla label del Totale
+     */
+    Total: {
+        Show: boolean;
+        TitleSize: number;
+        NumberSize: number;
+        UnitOfMeasure: string;
+    };
+}
+
+/**
+ * Classe che presenta le impostazioni di generazione per i grafici di tipo Vertical2DChart
+ */
+declare class Vertical2DChartSettings extends BaseSettings {
+    /**
+     * @ignore
+     */
+    constructor();
+    /**
+     * Indica la percentuale di cella che la colonna andrà a riempire. Un valore pari a 100 riempirà la cella completamente
+     * e tutte le barre risulteranno appiccicate l'un l'altra
+     */
+    ColumnWidthPercentage: number;
+    /**
+     * Indica le dimensioni massime della label associata a un gruppo di barre
+     */
+    LabelWidth: number;
+    /**
+     * Indica la dimensione massima sotto la quale la label associata a un gruppo di barre si inclina cercando di occupare meno spazio
+     */
+    LabelVerticalOrientationCutoffWidth: number;
+    /**
+     * Indica un offset orizzontale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelRightWhenCompressed: number;
+    /**
+     * Indica un offset verticale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelTopWhenCompressed: number;
+    /**
+    * Indica il padding percentuale rispetto alla cella da lasciare fra un gruppo di barre e l'altro. Un valore pari a 0 indica la mancanza di
+    * spazio fra un gruppo e l'altro, un valore pari a 5 indica il 5% della dimensione della cella in cui appare il gruppo come padding a destra e sinistra
+    */
+    GroupPaddingPercentage: number;
+}
+
+/**
+ * Classe che presenta le impostazioni di generazione per i grafici di tipo VerticalChart
+ */
+declare class VerticalChartSettings extends BaseSettings {
+    /**
+     * @ignore
+     */
+    constructor();
+    /**
+     * Indica la percentuale di cella che la colonna andrà a riempire. Un valore pari a 100 riempirà la cella completamente
+     * e tutte le barre risulteranno appiccicate l'un l'altra
+     */
+    ColumnWidthPercentage: number;
+    /**
+     * Indica le dimensioni massime della label associata a un gruppo di barre
+     */
+    LabelWidth: number;
+    /**
+     * Indica la dimensione massima sotto la quale la label associata a un gruppo di barre si inclina cercando di occupare meno spazio
+     */
+    LabelVerticalOrientationCutoffWidth: number;
+    /**
+     * Indica un offset orizzontale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelRightWhenCompressed: number;
+    /**
+     * Indica un offset verticale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelTopWhenCompressed: number;
+}
+
+/**
+ * Classe che presenta le impostazioni di generazione per i grafici di tipo VerticalStackedChart
+ */
+declare class VerticalStackedChartSettings extends BaseSettings {
+    /**
+     * @ignore
+     */
+    constructor();
+    /**
+     * Indica la percentuale di cella che la colonna andrà a riempire. Un valore pari a 100 riempirà la cella completamente
+     * e tutte le barre risulteranno appiccicate l'un l'altra
+     */
+    ColumnWidthPercentage: number;
+    /**
+     * Indica le dimensioni massime della label associata a un gruppo di barre
+     */
+    LabelWidth: number;
+    /**
+     * Indica la dimensione massima sotto la quale la label associata a un gruppo di barre si inclina cercando di occupare meno spazio
+     */
+    LabelVerticalOrientationCutoffWidth: number;
+    /**
+     * Indica un offset orizzontale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelRightWhenCompressed: number;
+    /**
+     * Indica un offset verticale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelTopWhenCompressed: number;
+}
+
+/**
+ * Classe che identifica i dati per un grafico generico paginato
+ */
+declare class PagedChartData<T extends LineChartData | PieChartData | Vertical2DChartData | VerticalChartData | VerticalStackedChartData | any> {
+    data: T;
+    title: string;
+    dataRetrieveDto: any;
+    dataRetrieveFunction: Function;
+    /**
+     * Costruttore
+     *
+     * @param {T} data Dati del grafico
+     * @param {string} title Titolo del grafico
+     * @param {Object} dataRetrieveDto Dto utilizzato per recuperare i dati di questo grafico
+     * @param {Function} dataRetrieveFunction Funzione utilizzata per ottenere i dati di questo grafico
+     */
+    constructor(data: T, title: string, dataRetrieveDto: any, dataRetrieveFunction: Function);
+}
+
+/**
+ * Componente che si occupa della paginazione dei grafici qualora servisse
+ */
+declare class PageChartSelector {
+    /**
+     * Lista dei dati precaricata in memoria
+     */
+    Items: PagedChartData<any>[];
+    /**
+     * Lista dei Dto da utilizzare per caricare i valori dei vari grafici
+     */
+    Dtos: any[];
+    /**
+     * Dopo aver navigato a un nuovo grafico verranno attesi questi millisecondi prima di richiedere i dati attraverso la **DataRetrieve**.
+     *
+     * Questo per evitare che l'utente cliccando velocemente "avanti" generi tonnellate di richieste inutili
+     */
+    BrowseDelayMs: any;
+    /**
+     * Indice dell'array **Dtos** o dell'array **Items** da cui iniziare ad emettere i valori, utile per supportare il "back" da un eventuale pagina di dettaglio
+     */
+    StartIndex: number;
+    /**
+     * Indica un cambio di pagina ed emette un oggetto con i dati attuali e l'indice attuale.
+     *
+     * Qualora la proprietà **data** fosse null indica un evento di "loading"
+     */
+    onPageChange: EventEmitter<{
+        data: any;
+        index: number;
+    }>;
+    /**
+     * Override del titolo di default
+     */
+    headerInner_tr: any;
+    /**
+     * @ignore
+     */
+    currentpage: number;
+    /**
+     * @ignore
+     */
+    private currentindex;
+    /**
+     * @ignore
+     */
+    private finalIndex;
+    /**
+     * @ignore
+     */
+    ngOnChanges(): void;
+    /**
+     * Gestisce un cambio pagina inviando al callback **onPageChange** i dati attuali (siano essi il Dto per il caricamento dati i
+     * o i dati già presenti) e l'indice di visualizzazione
+     */
+    private handlePageChange;
+    /**
+     * Visualizza il grafico successivo
+     */
+    Next(): void;
+    /**
+     * Visualizza il grafico precedente
+     */
+    Previous(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageChartSelector, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PageChartSelector, "chart-pager", never, { "Items": { "alias": "Items"; "required": false; }; "Dtos": { "alias": "Dtos"; "required": false; }; "BrowseDelayMs": { "alias": "BrowseDelayMs"; "required": false; }; "StartIndex": { "alias": "StartIndex"; "required": false; }; }, { "onPageChange": "onPageChange"; }, ["headerInner_tr"], never, false, never>;
+}
+
+/**
+ * Interfaccia rappresentante una Service di graficamento generica
+ */
+interface IBaseService<T> {
+    /**
+     * Adattatore che si occupa della trasformazione fra una tipologia di dati qualsiasi e i Dto utilizzati da questa libreria
+     */
+    Adapter: BaseAdapter;
+    /**
+     * Istanza del grafico vera e propria
+     */
+    ChartInstance: T;
+    /**
+     * Crea e disegna il grafico la prima volta
+     *
+     * @param {string} name Nome del grafico (Chiave univoca)
+     * @param {any} data Dati del grafico, o tipo specifico o tipolegacy che si occuperà di convertire l'**Adapter**
+     * @param {any} settings Impostazione per la generazione del grafico
+     * @returns {IBaseService<T>} Se stessa nello stato successivo alla graficazione
+     */
+    graphicate(name: string, data: any, settings: any): IBaseService<T>;
+    /**
+     * Aggiorna la sorgente dati del grafico senza ricrearlo da 0. Da usare al posto dei destroy-rebuild
+     *
+     * NOTA BENE: Mancano le implementazioni, eventualmente svilupparle
+     *
+     * @param {any} data Nuovi dati da sostituire a quelli precedenti
+     */
+    refreshData(data: any): void;
+    /**
+     * Imposta lo zoom dal **from** al **to**
+     *
+     * @param {Date} from Inizio dello zoom
+     * @param {Date} to Fine dello zoom
+     */
+    setSelection(from: Date, to: Date): void;
+}
+
+/**
+ * Classe di supporto al caricamento dinamico dei vari pezzi di amcharts che mi servono per il grafico (temi, locali, ecc...)
+ *
+ * Essenzialmente ogni volta che viene creato un grafico, questo acquisisce il tema e il locale applicato IN QUEL MOMENTO,
+ * questo significa che per creare due grafici con temi diversi bisogna fare:
+ *
+ * 1) Caricamento tema 1
+ *
+ * 2) Creazione grafico 1
+ *
+ * 3) Scaricamento tema 1
+ *
+ * 3) Caricamento tema 2
+ *
+ * 4) Creazione grafico 2
+ *
+ */
+declare class ChartLoader {
+    private logs;
+    /**
+     * Indica se attualmente ho le animazioni caricate in modo da non ricaricarle inutilmente
+     */
+    private AnimationsAreLoaded;
+    /**
+     * Indica l'ultimo tema caricato in modo da non ricaricarlo inutilmente qualora il prossimo grafico da creare richieda lo stesso tema
+     */
+    private LastLoadedTheme;
+    /**
+     * Cache dei temi (moduli caricati dinamicamente)
+     */
+    private themeCache;
+    /**
+     * Cache delle localizzazioni (moduli caricati dinamicamente)
+     */
+    private localizationCache;
+    /**
+     * @ignore
+     */
+    constructor(logs: boolean);
+    /**
+     * Applica il tema con le animazioni all'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    applyAnimations(chartsCore: any): Promise<any>;
+    /**
+     * De-applica il tema con le animazioni dall'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     * @returns {Promise} Promise che identifica la fine dello scarico
+     */
+    unapplyAnimations(chartsCore: any): Promise<any>;
+    /**
+     * Applica il tema specificato all'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     * @param {'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'} theme Tema da applicare
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    applyTheme(chartsCore: any, theme: 'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none'): Promise<any>;
+    /**
+     * De-applica il tema precedente dall'istanza globale di amCharts
+     *
+     * @param {Object} chartsCore Istanza globale di amCharts
+     */
+    unapplyPreviousTheme(chartsCore: any): void;
+    /**
+     * Applica il locale specificato all'istanza specifica del grafico
+     *
+     * @param {amCharts.Chart} chart Istanza specifica del grafico a cui applicare il locale
+     * @param {string} locale Locale da applicare
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    applyLocale(chart: any, locale: string): Promise<any>;
+    /**
+     * Permette di importare, se serve un dato tema o localizzazione
+     *
+     * @param {'lang' | 'themes'} what Oggetto da importare, se localizzazione o tema
+     * @param {string} item Chiave dell'oggetto da importare
+     *
+     * @returns {Promise} Promise che identifica la fine del caricamento
+     */
+    importIfNeeded(what: 'lang' | 'themes', item: string): Promise<any>;
+    /**
+     * @ignore
+     */
+    log(text: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartLoader>;
+}
+
+/**
+ * Classe che si occupa del dispatch delle operazioni di rendering dei grafici utilizzando una coda per permettere ad ogni grafico di avere temi e localizzazione custom
+ */
+declare class ChartDispatcher {
+    private logs;
+    /**
+     * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando grafici
+     */
+    private Initializations;
+    /**
+     * Lista dei grafici inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo
+     */
+    private InitializedGraphs;
+    /**
+     * @ignore
+     */
+    constructor(logs: boolean);
+    /**
+     * Registra un grafico da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti i grafici
+     * precedentemente registati non hanno finito la fase di inizializzazione
+     *
+     * @param {string} name Identificativo del grafico da registrare
+     * @param {Function} chartCreationFunction Funzione che fisicamente dovrà occuparsi della creazione del grafico
+     */
+    register(name: string, chartCreationFunction: Function): void;
+    /**
+     * Deregistra un grafico presente. Chiamata generalmente al dispose del grafico in questione quando non dev'essere più mostrato nella pagina corrente
+     *
+     * @param {string} name Identificativo del grafico da deregistrare
+     */
+    deregisterGraph(name: string): void;
+    /**
+     * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione dei grafici finché presenti
+     * in modo che nessun grafico possa essere inizializzato contemporaneamente ad un altro.
+     *
+     * Questo è il punto chiave che permette di avere per ogni grafico temi e locale differenti
+     */
+    private drainInitQueues;
+    /**
+     * @ignore
+     */
+    private log;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartDispatcher>;
+}
+
+/**
+ * Componente Grafico Base che gestisce tutte le cose comuni dei vari grafici istanziabili, come la presenza o menu di una legenda,
+ * il tema utilizzato, il locale del singolo grafico, ecc ecc...
+ */
+declare abstract class BaseChartComponent implements AfterViewInit, OnDestroy, OnInit, OnChanges {
+    private el;
+    private platformId;
+    private zone;
+    private Charter;
+    private Dispatcher;
+    private logs;
+    private animations;
+    private locale;
+    private theme;
+    /**
+     * Titolo per l'asse X
+     */
+    XTitle: string;
+    /**
+     * Titolo per l'asse Y
+     */
+    YTitle: string;
+    /**
+     * Impostazioni di base
+     */
+    Settings: BaseSettings;
+    /**
+     * Presenza o meno della legenda
+     */
+    Legend: boolean;
+    /**
+     * Posizione della legenda
+     */
+    LegendPosition: "top" | "bottom" | "left" | "right";
+    /**
+     * Presenza o meno della timeline
+     */
+    Timeline: boolean;
+    /**
+     * Nome del grafico, fondamentale assegnarlo per permettere alla libreria di schedularne la creazione
+     */
+    name: string;
+    /**
+     * Utilizzo o meno delle animazioni. Senza animazioni il grafico è leggermente più performante, specialmente all'aumentare dei punti nella serie
+     */
+    Animations: boolean;
+    /**
+     * Tema da utilizzare, valido solo per il grafico in questione. Gli altri grafici della pagina possono avere stili diversi.
+     *
+     * Essendo i temi caricati in maniera asincrona in base all'utilizzo utilizzarne tanti diversi in un'unica pagina potrebbe rallentare il primo caricamento
+     */
+    Theme: 'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none';
+    /**
+     * Locale del singolo grafico
+     */
+    Locale: string;
+    /**
+     * Indica se utilizzare il comportamento di default per i click delle serie sulla Legenda. Mettendo questa variabile a **false**
+     * e collegando l'output **onSeriesClicked** è possibile generare un evento ogni volta che l'utente fa click su una serie della Legenda
+     */
+    HideSeriesOnLabelClick: boolean;
+    /**
+     * Minima distanza nella griglia fra i valori, modifica la quantità di step fra i valori dell'asse X e quindi la granularità dei dati.
+     *
+     * Più piccola è, più valori verranno inseriti nell'asse X
+     */
+    MinGridDistance: number;
+    /**
+     * Cerca di aggiustare i vari step dell'asse X ruotandoli e diminuendone le dimensioni abbastanza per mostrarne il più possibile
+     */
+    AdaptLabelSizeAndOrientation: boolean;
+    /**
+     * Padding da applicare alla Legenda in caso si voglia spostare un po'
+     */
+    LegendPadding: LegendPad;
+    /**
+     * Lista di dto generici che verranno emessi dal sistema di grafici uno per uno attraverso la funzione **DataRetrieve**, che dovranno essere
+     * usati per uan sorta di caricamento "paginato" dei grafici
+     */
+    DataDtos: any[];
+    /**
+     * Indice dell'array **DataDtos** o dell'array **DataArray** da cui iniziare ad emettere i valori, utile per supportare il "back" da un eventuale pagina di dettaglio
+     */
+    DataDtoStartIndex: number;
+    /**
+     * Funzione definita lato applicativo che in base al **DataDto** corrente restituisce una Promise del tipo di dati richiesto per il grafico corrente
+     */
+    DataRetrieve: (dto: any, index: number) => Promise<any>;
+    /**
+     * Dopo aver navigato a un nuovo grafico verranno attesi questi millisecondi prima di richiedere i dati attraverso la **DataRetrieve**.
+     *
+     * Questo per evitare che l'utente cliccando velocemente "avanti" generi tonnellate di richieste inutili
+     */
+    BrowseDelayMs: number;
+    /**
+     * Intestazione dei grafici nel caso si utilizzi la modalità paginata
+     */
+    header_tr: any;
+    /**
+     * Messaggio di caricamento fra un grafico e l'altro
+     */
+    loading_template: any;
+    /**
+     * Evento lanciato sulla selezione di un range di dati o dalla timeline o dal grafico. Valido per tutti i grafici che supportano serie basate sulle date
+     */
+    onSelectionChanged: EventEmitter<{
+        from: Date;
+        to: Date;
+        initial: boolean;
+    }>;
+    /**
+     * Evento lanciato dal click di una serie dalla Legenda, a patto che l'Input **HideSeriesOnLabelClick** sia impostato a false
+     */
+    onSeriesClicked: EventEmitter<string>;
+    /**
+     * Evento lanciato all'inizio del caricamento di una nuova pagina del grafico
+     */
+    onLoadStart: EventEmitter<void>;
+    /**
+     * Evento lanciato al termine del caricamento di una nuova pagina del grafico
+     */
+    onLoadEnd: EventEmitter<void>;
+    /**
+    * Evento lanciato al termine della creazione del grafico referenziando l'istanza nativa del grafico creato in modo da poter effettuare modifiche
+    * post inizializzazione lato applicativo
+    */
+    chartLoaded: EventEmitter<BaseChartComponent>;
+    /**
+     * Serve a decidere se sarà presente l'interfaccia di paginazione
+     */
+    isPaged: boolean;
+    /**
+     * @ignore
+     */
+    private initDone;
+    /**
+     * Istanza nativa del grafico amcharts. Qualsiasi cosa non fa questa libreria si può prendere questa istanza e modificare a piacimento
+     */
+    Chart: am4charts.Chart;
+    /**
+     * Servizio di graficazione del grafico
+     */
+    ChartService: IBaseService<any>;
+    /**
+     * Variabile che indica se una nuova pagina del grafico è in fase di caricamento
+     */
+    loadingChart: boolean;
+    /**
+     * Dati del grafico. Ogni implementazione gestirà questa variabile in base al proprio tipo di Dati
+     */
+    abstract Data: any;
+    /**
+     * Dati del grafico in modalità paginata, per quando tutte le pagine sono precaricate in memoria (in caso contrario verrebberò utilizzati i **DataDtos**)
+     */
+    abstract DataArray: PagedChartData<any>[];
+    /**
+     * Indica le proprietà specifica per una data implementazione che devono causare un repaint del grafico
+     */
+    abstract getSpecificPropertiesToCheck(): string[];
+    /**
+     * Metodo generico di graficazione, reimplementato dalle varie implementazioni
+     */
+    abstract graphicate(castedSettings: any): IBaseService<any>;
+    /**
+     * Metodo generico che prende le impostazioni generiche del grafico e le casta alla tipologia giusta per il grafico specifico
+     */
+    abstract getCastedSettings(): any;
+    /**
+     * Metodo che "Riempie" la classe delle impostazioni con tutte le impostazioni specifiche passate a un dato grafico come Input
+     */
+    abstract fillSpecificSettings(settingsCasted: any): void;
+    /**
+     * Costruttore
+     *
+     * @param {ElementRef} el Contenitore all'interno del cui viene creato il grafico. Utilizzato per estrapolarne la **ContainerHeight**
+     * @param {Object} platformId piattaforma Angular (browser, ecc...) per essere sicuri che amcharts venga attivato solo lato browser. Non utilizzando SSR nelle applicazioni che consumano questa libreria non è particolarmente significativo, ma non si sa mai
+     * @param {NgZone} zone NgZone di default per permettere di inizializzare il grafico all'infuori di Angular per avere qualche prestazione in più
+     * @param {ChartLoader} Charter Istanza del Loader che si occuperà di caricare in memoria tutto ciò che serve per il grafico attuale (temi, locale, animazioni, ecc...)
+     * @param {ChartDispatcher} Dispatcher Istanza del Dispatcher che si occupa di differire il caricamento dei grafici 1 dopo l'altro in modo che caricamenti pseudo paralleli incasinino tutto
+     * @param {boolean} logs Indica se effettuare log a console o meno, iniettato dalle classi specializzate dal token ESC_DEBUG_MODE
+     * @param {boolean} animations Indica se per questo grafico devono essere attive o meno le animazioni. Impostazione generica presa dal token ESC_ANIMATIONS
+     * @param {string} locale Indica il locale specifico per questo grafico. Impostazione generica presa dal LocalizationService
+     * @param {string} theme Indica il tema specifico per questo grafico. Impostazione generica presa dal token ESC_THEME
+     */
+    constructor(el: ElementRef, platformId: Object, zone: NgZone, Charter: ChartLoader, Dispatcher: ChartDispatcher, logs: boolean, animations: boolean, locale: string, theme: string);
+    /**
+     * Metodo di inizializzazione post valorizzazione degli input, utilizzato per valorizzare correttamente le proprietà essenziali del grafico (Animazioni, Tema e Locale)
+     *
+     * Viene data priorità ai Settings (HTML), priorità secondaria agli Input diretti (Lato HTML), priorità ultima alle impostazioni globali,
+     * impostate in fase di import del modulo assegnando valori ai token ESC_ANIMATIONS, ESC_THEME
+     */
+    ngOnInit(): void;
+    /**
+     * Implementazione utilizzata per controllare eventuali proprietà chiave del grafico e rigraficare tutto qualora si rivelasse necessario
+     *
+     * @param {SimpleChanges} changes Indicazione dei cambiamenti sulle proprietà del grafico. Vedere documentazione Angular in merito
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Nel post inizializzazione, a patto che mi trovi in ambiente "browser", proseguo al caricamento del grafico sull'HTML
+     */
+    ngAfterViewInit(): void;
+    /**
+     * All'onDestroy scarico il grafico per liberare memoria
+     */
+    ngOnDestroy(): void;
+    /**
+     * Registra il grafico attuale nel Dispatcher in modo che venga caricato appena possibile
+     */
+    private dispatchLoadChart;
+    /**
+     * Il caricamento del grafico funziona nel seguente modo:
+     *
+     * 1) Caricamento del tema e delle animazioni, qualora necessari
+     *
+     * 2) Caricamento delle impostazioni specifiche e integrazione con le impostazioni generiche
+     *
+     * 3) Graficazione
+     *
+     * 4) Caricamento del locale
+     */
+    private loadChart;
+    /**
+     * Riempimento delle impostazioni nella classe Settings. Si danno priorità ai valori già impostati nei Settings,
+     * integrando eventualmente con le  proprietà del grafico
+     *
+     * @param {BaseSettings} settings Impostazioni base ricevute dalla specializzazione del grafico
+     */
+    private fillSettings;
+    /**
+     * Controlla i cambiamenti avvenuti alle proprietà chiave e rieffettua la graficazione qualora necessario
+     *
+     * @param {SimpleChanges} changes Indicazione della modifiche avvenute nei vari Input
+     * @param {string[]} propsToCheck Lista degli Input da controllare per cui una modifica causa una rigraficazione
+     */
+    private checkPropertiesAndRegraphicateAsNeeded;
+    /**
+     * Funzione che effettua un cambio di pagina per i grafici paginati. Qualora **data** fosse nullo significa che è iniziato un caricamento
+     * e anche lato applicativo il DataRetrieve dovrà considerare che l'assenza di valori non è altro che un'indicazione di inizio caricamento
+     *
+     * Il caricamento di qualsiasi pagina genererà comunque una primo evento con **data** nullo in modo da indicare l'inizio caricamento e
+     * in seconda istanza un altro evento in cui **data** sarà sempre valorizzato, o con il Dto da usare per recuperare i dati, o con i dati
+     * veri e propri già presenti nel **DataArray**
+     *
+     * I callback **onLoadStart** e **onLoadEnd** vengono sempre chiamati
+     *
+     * @param {{ data: LineChartData | PieChartData | Vertical2DChartData | VerticalChartData | any, index: number }} nd Indice del caricamento dati, con eventualmente già i dati se disponibili
+     */
+    changePage(nd: {
+        data: LineChartData | PieChartData | Vertical2DChartData | VerticalChartData | any;
+        index: number;
+    }): void;
+    /**
+     * Al termine del caricamento dei dati di una pagina questo metodo viene chiamato per rigraficare la situazione con i nuovi dati
+     *
+     * @param {LineChartData | PieChartData | Vertical2DChartData | VerticalChartData | any} data Dati del grafico
+     */
+    private changePageDataReceived;
+    /**
+     * Ricarica il grafico distruggendo il vecchio e ricreando il nuovo
+     *
+     * Le chiamate a questo metodo possono essere trasformate in chiamate al metodo **graphicate** della Service, se solo quel metodo fosse abbastanza intelligente per capire
+     * le differenze fra il grafico com'era prima e come deve diventare, in modo da non ricrearlo ma semplicemente modificare quello che già è disegnato
+     */
+    private reloadChart;
+    /**
+     * Permette di aggiungere un blocco di dati in maniera "live" ad un grafico
+     */
+    addData(chartData: any): void;
+    /**
+     * Funzione che si occupa di caricare i temi necessari per il grafico in oggetto. Prima applica il tema, poi, se serve, applica le animazioni
+     */
+    private setupAmChartsThemes;
+    /**
+     * @ignore
+     */
+    private log;
+    /**
+     * Imposta lo zoom dal **from** al **to**
+     *
+     * @param {Date} from Inizio dello zoom
+     * @param {Date} to Fine dello zoom
+     */
+    setSelection(from: Date, to: Date): void;
+    /**
+     * @ignore
+     */
+    browserOnly(f: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseChartComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseChartComponent, never, never, { "XTitle": { "alias": "XTitle"; "required": false; }; "YTitle": { "alias": "YTitle"; "required": false; }; "Settings": { "alias": "Settings"; "required": false; }; "Legend": { "alias": "Legend"; "required": false; }; "LegendPosition": { "alias": "LegendPosition"; "required": false; }; "Timeline": { "alias": "Timeline"; "required": false; }; "name": { "alias": "name"; "required": false; }; "Animations": { "alias": "Animations"; "required": false; }; "Theme": { "alias": "Theme"; "required": false; }; "Locale": { "alias": "Locale"; "required": false; }; "HideSeriesOnLabelClick": { "alias": "HideSeriesOnLabelClick"; "required": false; }; "MinGridDistance": { "alias": "MinGridDistance"; "required": false; }; "AdaptLabelSizeAndOrientation": { "alias": "AdaptLabelSizeAndOrientation"; "required": false; }; "LegendPadding": { "alias": "LegendPadding"; "required": false; }; "DataDtos": { "alias": "DataDtos"; "required": false; }; "DataDtoStartIndex": { "alias": "DataDtoStartIndex"; "required": false; }; "DataRetrieve": { "alias": "DataRetrieve"; "required": false; }; "BrowseDelayMs": { "alias": "BrowseDelayMs"; "required": false; }; }, { "onSelectionChanged": "onSelectionChanged"; "onSeriesClicked": "onSeriesClicked"; "onLoadStart": "onLoadStart"; "onLoadEnd": "onLoadEnd"; "chartLoaded": "chartLoaded"; }, ["header_tr", "loading_template"], never, true, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un qualsiasi tipo di grafico.
+ *
+ * Si basa sul tipo specificato dalla proprietà **Type**
+ */
+declare class EsChartComponent extends BaseChartComponent {
+    private dateService;
+    private adapter;
+    /**
+     * Tipologia di grafico da presentare
+     */
+    Type: 'pie' | 'line' | 'vertical' | 'vertical-2d' | 'vertical-stacked' | 'area';
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo giusto col supporto del **BaseAdapter**
+     */
+    Data: LineChartData | PieChartData | Vertical2DChartData | VerticalChartData | VerticalStackedChartData | AreaChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo giusto col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<LineChartData>[] | PagedChartData<PieChartData>[] | PagedChartData<Vertical2DChartData>[] | PagedChartData<VerticalChartData>[] | PagedChartData<VerticalStackedChartData>[] | PagedChartData<AreaChartData>[] | PagedChartData<any>[];
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, dateService: DateService, adapter: BaseAdapter, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {PieChartSettings | AreaChartSettings | LineChartSettings | VerticalChartSettings | Vertical2DChartSettings | VerticalStackedChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): AreaChartSettings | LineChartSettings | PieChartSettings | Vertical2DChartSettings | VerticalChartSettings | VerticalStackedChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {PieChartSettings | AreaChartSettings | LineChartSettings | VerticalChartSettings | Vertical2DChartSettings | VerticalStackedChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: PieChartSettings | AreaChartSettings | LineChartSettings | VerticalChartSettings | Vertical2DChartSettings | VerticalStackedChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {PieChartSettings | AreaChartSettings | LineChartSettings | VerticalChartSettings | Vertical2DChartSettings | VerticalStackedChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {PieChartService | AreaChartService | LineChartService | VerticalChartService | Vertical2DChartService | VerticalStackedChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settings: PieChartSettings | AreaChartSettings | LineChartSettings | VerticalChartSettings | Vertical2DChartSettings | VerticalStackedChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsChartComponent, "es-chart", never, { "Type": { "alias": "Type"; "required": false; }; "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un grafico ad Area
+ */
+declare class EsAreaChartComponent extends BaseChartComponent {
+    private adapter;
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo **AreaChartData** col supporto del **BaseAdapter**
+     */
+    Data: AreaChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo **AreaChartData** col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<AreaChartData>[] | PagedChartData<any>[];
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, adapter: BaseAdapter, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {AreaChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): AreaChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {AreaChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: AreaChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {AreaChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {AreaChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settingsCasted: AreaChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsAreaChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsAreaChartComponent, "es-area-chart", never, { "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un grafico a Linea su un asse temporale
+ */
+declare class EsLineChartComponent extends BaseChartComponent {
+    private adapter;
+    private dateService;
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo **LineChartData** col supporto del **BaseAdapter**
+     */
+    Data: LineChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo **LineChartData** col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<LineChartData>[] | PagedChartData<any>[];
+    /**
+     * Indica se la curva deve collegare direttamente un datapoint all'altro o se deve fare degli step
+     */
+    Step: boolean;
+    /**
+     * Indica il numero massimo di datapoint visualizzabile in una singola vista del grafico. L'eccedenza viene raggruppata e verrà mostrata sullo zoom.
+     *
+     * ATTENZIONE: Utilizzando il sistema di default di raggruppamento di am-charts si rischia di tagliare via pezzi da serie molto ondulate
+     * in quanto il comportamento di default è quello di eliminare i datapoint che non ci stanno, non di interpolarli
+     */
+    DataGroupBucketSize: number;
+    /**
+     * Soglia per controllare oltre che numero di datapoint il grafico deve iniziare ad effettuare raggruppamenti considerando l'Input **DataGroupBucketSize**
+     */
+    DataGroupingThreshold: number;
+    /**
+     * Indica le dimnsioni, in pixel della linea del grafico
+     */
+    StrokeSize: number;
+    /**
+     * Indica se sono permessi dei Gap fra un valore e l'altro.
+     *
+     * Normalmente quando ci sono dei buchi l'ultimo datapoint del buco viene collegato direttamente al primo datapoint disponibile.
+     *
+     * Impostando questo Input a true invece, posto di aver assegnato la variabile **interval** della classe **LineChartData**, è possibile
+     * far apparire il blocco di dati mancanti come un buco vero e proprio, senza alcun collegamento fra i due datapoint estremi
+     */
+    AllowGaps: boolean;
+    /**
+     * Input che permette di rielaborare i dati del grafico per generare un solo Dataset
+     *
+     * Viene utilizzato semplicemente per dare un tooltip molto più bello/avanzato sullo scorrimentodel cursore all'interno del grafico
+     */
+    MergeDatasets: boolean;
+    /**
+     * Indica se le date che arrivano all'asse X devono essere considerate "Istante finale" e aggiustate di conseguenza.
+     * Se non è valorizzata la variabile **interval** della classe **LineChartData** non ha alcun effetto
+     *
+     * Ad esempio, la data 16/07/2021 con intervallo orario verrebbe trasformata in 15/07/2021 24:00:00 (Ovviamente è utilizzato solo lato presentazione)
+     */
+    FinalInstants: boolean;
+    /**
+     * Gestisce il minimo dell'asse Y
+     */
+    Min: number;
+    /**
+     * Gestisce il massimo dell'asse Y
+     */
+    Max: number;
+    /**
+     * Indica se effettuare il Fill della serie in modo da non vedere solo la linea ma proprio l'area sottessa completamente colorata
+     */
+    Fill: boolean;
+    /**
+     * Indica se effettuare lo Stack della serie in modo da vedere tutte le linee una sopra l'altra. Implicitamente include anche il **Fill**
+     */
+    Stacked: boolean;
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, adapter: BaseAdapter, dateService: DateService, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {LineChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): LineChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {LineChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: LineChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {LineChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {LineChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settingsCasted: LineChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsLineChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsLineChartComponent, "es-line-chart", never, { "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; "Step": { "alias": "Step"; "required": false; }; "DataGroupBucketSize": { "alias": "DataGroupBucketSize"; "required": false; }; "DataGroupingThreshold": { "alias": "DataGroupingThreshold"; "required": false; }; "StrokeSize": { "alias": "StrokeSize"; "required": false; }; "AllowGaps": { "alias": "AllowGaps"; "required": false; }; "MergeDatasets": { "alias": "MergeDatasets"; "required": false; }; "FinalInstants": { "alias": "FinalInstants"; "required": false; }; "Min": { "alias": "Min"; "required": false; }; "Max": { "alias": "Max"; "required": false; }; "Fill": { "alias": "Fill"; "required": false; }; "Stacked": { "alias": "Stacked"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un grafico a Torta
+ */
+declare class EsPieChartComponent extends BaseChartComponent {
+    private adapter;
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo **PieChartData** col supporto del **BaseAdapter**
+     */
+    Data: PieChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo **PieChartData** col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<PieChartData>[] | PagedChartData<any>[];
+    /**
+     * Indica se mostrare o meno le serie con percentuale a 0
+     */
+    HideZeroes: boolean;
+    /**
+     * Indica se apparire in modalità 3D o 2D
+     */
+    Mode3D: boolean;
+    /**
+     * Percentuale dell'altezza del grafico che viene utilizzata per creare il buco all'interno della ciambella **wink** **wink**
+     */
+    DonutRadiusPercentage: number;
+    /**
+     * Indica se wrappare le label che non stanno nel contenitore
+     */
+    LabelsWrap: boolean;
+    /**
+     * Indica se troncare le label che non stanno nel contenitore
+     */
+    LabelsTruncate: boolean;
+    /**
+     * Indica la dimensione massima che possono assumere le label
+     */
+    LabelsWidth: number;
+    /**
+     * Indica se mostrare o meno le labels
+     */
+    LabelsVisible: boolean;
+    /**
+     * Indica se mostrare o meno le labels
+     */
+    Total: {
+        Show: boolean;
+        TitleSize: number;
+        NumberSize: number;
+        UnitOfMeasure: string;
+    };
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, adapter: BaseAdapter, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {PieChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): PieChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {PieChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: PieChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {PieChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {PieChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settingsCasted: PieChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsPieChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsPieChartComponent, "es-pie-chart", never, { "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; "HideZeroes": { "alias": "HideZeroes"; "required": false; }; "Mode3D": { "alias": "Mode3D"; "required": false; }; "DonutRadiusPercentage": { "alias": "DonutRadiusPercentage"; "required": false; }; "LabelsWrap": { "alias": "LabelsWrap"; "required": false; }; "LabelsTruncate": { "alias": "LabelsTruncate"; "required": false; }; "LabelsWidth": { "alias": "LabelsWidth"; "required": false; }; "LabelsVisible": { "alias": "LabelsVisible"; "required": false; }; "Total": { "alias": "Total"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un grafico a Barre con due dimensioni
+ */
+declare class EsVertical2DChartComponent extends BaseChartComponent {
+    private adapter;
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo **Vertical2DChartData** col supporto del **BaseAdapter**
+     */
+    Data: Vertical2DChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo **Vertical2DChartData** col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<Vertical2DChartData>[] | PagedChartData<any>[];
+    /**
+     * Indica la percentuale di cella che la colonna andrà a riempire. Un valore pari a 100 riempirà la cella completamente
+     * e tutte le barre risulteranno appiccicate l'un l'altra
+     */
+    ColumnWidthPercentage: number;
+    /**
+     * Indica il padding percentuale rispetto alla cella da lasciare fra un gruppo di barre e l'altro. Un valore pari a 0 indica la mancanza di
+     * spazio fra un gruppo e l'altro, un valore pari a 5 indica il 5% della dimensione della cella in cui appare il gruppo come padding a destra e sinistra
+     */
+    GroupPaddingPercentage: number;
+    /**
+     * Indica le dimensioni massime della label associata a un gruppo di barre
+     */
+    LabelWidth: number;
+    /**
+     * Indica la dimensione massima sotto la quale la label associata a un gruppo di barre si inclina cercando di occupare meno spazio
+     */
+    LabelVerticalOrientationCutoffWidth: number;
+    /**
+     * Indica un offset orizzontale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelRightWhenCompressed: number;
+    /**
+     * Indica un offset verticale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelTopWhenCompressed: number;
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, adapter: BaseAdapter, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {Vertical2DChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): Vertical2DChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {Vertical2DChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: Vertical2DChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {Vertical2DChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {Vertical2DChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settingsCasted: Vertical2DChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsVertical2DChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsVertical2DChartComponent, "es-vertical-2d-chart", never, { "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; "ColumnWidthPercentage": { "alias": "ColumnWidthPercentage"; "required": false; }; "GroupPaddingPercentage": { "alias": "GroupPaddingPercentage"; "required": false; }; "LabelWidth": { "alias": "LabelWidth"; "required": false; }; "LabelVerticalOrientationCutoffWidth": { "alias": "LabelVerticalOrientationCutoffWidth"; "required": false; }; "LabelRightWhenCompressed": { "alias": "LabelRightWhenCompressed"; "required": false; }; "LabelTopWhenCompressed": { "alias": "LabelTopWhenCompressed"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un grafico a Barre
+ */
+declare class EsVerticalChartComponent extends BaseChartComponent {
+    private adapter;
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo **VerticalChartData** col supporto del **BaseAdapter**
+     */
+    Data: VerticalChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo **VerticalChartData** col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<VerticalChartData>[] | PagedChartData<any>[];
+    /**
+     * Indica la percentuale di cella che la colonna andrà a riempire. Un valore pari a 100 riempirà la cella completamente
+     * e tutte le barre risulteranno appiccicate l'un l'altra
+     */
+    ColumnWidthPercentage: number;
+    /**
+     * Indica le dimensioni massime della label associata a un gruppo di barre
+     */
+    LabelWidth: number;
+    /**
+     * Indica la dimensione massima sotto la quale la label associata a un gruppo di barre si inclina cercando di occupare meno spazio
+     */
+    LabelVerticalOrientationCutoffWidth: number;
+    /**
+     * Indica un offset orizzontale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelRightWhenCompressed: number;
+    /**
+     * Indica un offset verticale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelTopWhenCompressed: number;
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, adapter: BaseAdapter, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {VerticalChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): VerticalChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {VerticalChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: VerticalChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {VerticalChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {VerticalChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settingsCasted: VerticalChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsVerticalChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsVerticalChartComponent, "es-vertical-chart", never, { "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; "ColumnWidthPercentage": { "alias": "ColumnWidthPercentage"; "required": false; }; "LabelWidth": { "alias": "LabelWidth"; "required": false; }; "LabelVerticalOrientationCutoffWidth": { "alias": "LabelVerticalOrientationCutoffWidth"; "required": false; }; "LabelRightWhenCompressed": { "alias": "LabelRightWhenCompressed"; "required": false; }; "LabelTopWhenCompressed": { "alias": "LabelTopWhenCompressed"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Componente specifico per la graficazione di un grafico a Barre in modalità Stacked (una serie sopra l'altra)
+ */
+declare class EsVerticalStackedChartComponent extends BaseChartComponent {
+    private adapter;
+    /**
+     * Dati specifici per il grafico o di un tipo tramutabile al tipo **VerticalStackedChartData** col supporto del **BaseAdapter**
+     */
+    Data: VerticalStackedChartData | any;
+    /**
+     * Lista di Dati specifici per un grafico paginato o di cui ogni blocco dati è tramutabile al tipo **VerticalStackedChartData** col supporto del **BaseAdapter**
+     */
+    DataArray: PagedChartData<VerticalStackedChartData>[] | PagedChartData<any>[];
+    /**
+     * Indica la percentuale di cella che la colonna andrà a riempire. Un valore pari a 100 riempirà la cella completamente
+     * e tutte le barre risulteranno appiccicate l'un l'altra
+     */
+    ColumnWidthPercentage: number;
+    /**
+     * Indica le dimensioni massime della label associata a un gruppo di barre
+     */
+    LabelWidth: number;
+    /**
+     * Indica la dimensione massima sotto la quale la label associata a un gruppo di barre si inclina cercando di occupare meno spazio
+     */
+    LabelVerticalOrientationCutoffWidth: number;
+    /**
+     * Indica un offset orizzontale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelRightWhenCompressed: number;
+    /**
+     * Indica un offset verticale da applicare alla label associata a un gruppo di barre qualora fosse compressa a causa della mancanza di spazio
+     */
+    LabelTopWhenCompressed: number;
+    /**
+     * @ignore
+     */
+    constructor(el: ElementRef, ChartLoader: ChartLoader, ChartDispatcher: ChartDispatcher, adapter: BaseAdapter, zone: NgZone, platformId: Object, ESC_DEBUG_MODE: boolean, ESC_ANIMATIONS: boolean, ESC_THEME: string, lc: LocalizationService);
+    /**
+     * Ottiene le proprietà specifiche per questa tipologia di grafico per cui serve rigraficare
+     */
+    getSpecificPropertiesToCheck(): string[];
+    /**
+     * Ottiene i Settings (Ereditati dalla classe base, quindi del tipo generico **BaseSettings**) castati al tipo specifico per questo grafico
+     *
+     * @returns {VerticalStackedChartSettings} Settings castati al tipo giusto
+     */
+    getCastedSettings(): VerticalStackedChartSettings;
+    /**
+     * Integra i Settings base con tutti gli Input specifici di questo grafico, dando priorità ai Settings se definiti
+     *
+     * @param {VerticalStackedChartSettings} settingsCasted Settings castati al tipo giusto
+     */
+    fillSpecificSettings(settingsCasted: VerticalStackedChartSettings): void;
+    /**
+     * Effettua il rendering di questo grafico in base ai Settings
+     *
+     * @param {VerticalStackedChartSettings} settingsCasted Impostazioni di graficazione
+     * @returns {VerticalStackedChartService} La service utilizzata per il rendering nello stato subito successivo al rendering effettuato
+     */
+    graphicate(settingsCasted: VerticalStackedChartSettings): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsVerticalStackedChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EsVerticalStackedChartComponent, "es-vertical-stacked-chart", never, { "Data": { "alias": "Data"; "required": false; }; "DataArray": { "alias": "DataArray"; "required": false; }; "ColumnWidthPercentage": { "alias": "ColumnWidthPercentage"; "required": false; }; "LabelWidth": { "alias": "LabelWidth"; "required": false; }; "LabelVerticalOrientationCutoffWidth": { "alias": "LabelVerticalOrientationCutoffWidth"; "required": false; }; "LabelRightWhenCompressed": { "alias": "LabelRightWhenCompressed"; "required": false; }; "LabelTopWhenCompressed": { "alias": "LabelTopWhenCompressed"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Classe per enumerare i temi disponibili nella libreria
+ */
+declare class ChartThemes {
+    get spiritedaway(): string;
+    get moonrisekingdom(): string;
+    get frozen(): string;
+    get dark(): string;
+    get kelly(): string;
+    get material(): string;
+    get dataviz(): string;
+    get none(): string;
+    get animated(): string;
+    static get spiritedaway(): string;
+    static get moonrisekingdom(): string;
+    static get frozen(): string;
+    static get dark(): string;
+    static get kelly(): string;
+    static get material(): string;
+    static get dataviz(): string;
+    static get none(): string;
+    static get animated(): string;
+}
+
+/**
+ * Classe di configurazione per il modulo entry point della libreria
+ */
+declare class EsChartsModuleConfig {
+    /**
+     * Utilizzo o meno di default delle animazioni nei grafici
+     */
+    animations?: boolean;
+    /**
+     * Tema di default per i grafici
+     */
+    theme?: 'spiritedaway' | 'moonrisekingdom' | 'frozen' | 'dark' | 'kelly' | 'material' | 'dataviz' | 'none';
+    /**
+     * Adapter per trasformare i dati dei grafici da una versione precedente (con libreria di terze parti) ad una versione digeribile da questa libreria
+     *
+     * Deve implementare l'interfaccia IBaseAdapter
+     */
+    adapter?: Type<any>;
+    /**
+     * Serve per eventualmente attivare la modalità di debug in cui i messaggi vengono tutti scritti a console
+     */
+    debugMode?: boolean;
+}
+
+declare class EsChartsModule {
+    static forRoot(config?: EsChartsModuleConfig): ModuleWithProviders<EsChartsModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsChartsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EsChartsModule, [typeof EsChartComponent, typeof EsLineChartComponent, typeof EsPieChartComponent, typeof EsVertical2DChartComponent, typeof EsVerticalChartComponent, typeof EsVerticalStackedChartComponent, typeof PageChartSelector, typeof EsAreaChartComponent], [typeof i9.CommonModule], [typeof EsChartComponent, typeof EsLineChartComponent, typeof EsPieChartComponent, typeof EsVertical2DChartComponent, typeof EsVerticalChartComponent, typeof EsVerticalStackedChartComponent, typeof PageChartSelector, typeof EsAreaChartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EsChartsModule>;
+}
+
+/**
+ * Token che identifica il default per l'utilizzo o meno delle Animazioni per tutti i grafici, può essere sovrascritto dalle impostazioni locali (Settings e Input)
+ */
+declare const ESC_ANIMATIONS: InjectionToken<boolean>;
+/**
+ * Token che identifica il Tema di default per tutti i grafici, può essere sovrascritto dalle impostazioni locali (Settings e Input)
+ */
+declare const ESC_THEME: InjectionToken<string>;
+/**
+ * Token che identifica l'utilizzo o meno del sistema di Log per l'intera libreria
+ */
+declare const ESC_DEBUG_MODE: InjectionToken<string>;
+
+export { AreaChartData, AreaChartSettings, BaseAdapter, BaseChartComponent, BaseInterval, BaseSettings, ChartThemes, DateValue, ESC_ANIMATIONS, ESC_DEBUG_MODE, ESC_THEME, EsAreaChartComponent, EsChartComponent, EsChartsModule, EsLineChartComponent, EsPieChartComponent, EsVertical2DChartComponent, EsVerticalChartComponent, EsVerticalStackedChartComponent, KeyValue, KeyValueColor, LegendPad, Limit, LineChartData, LineChartSettings, LineSerie, PageChartSelector, PagedChartData, PieChartData, PieChartSettings, Vertical2DChartData, Vertical2DChartSettings, VerticalChartData, VerticalChartSettings, VerticalStackedChartData, VerticalStackedChartSettings };
+export type { IBaseAdapter };