@esfaenza/extensions 20.3.2 → 20.3.3

package/lib/models/CallResult.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Classe che rappresenta una risposta ricevuta da un Backend
+ */
+export declare class CallResult<T = never> {
+    /** Tempo impiegato perché la chiamata terminasse */
+    elapsedtime: string;
+    /** **true** se tutto è andato bene, **false** altrimenti */
+    success: boolean;
+    /** Indica se ci sono errori */
+    haserror: boolean;
+    /** Codice dell'eventuale errore restituito */
+    errorcode: string;
+    /** Log dell'eventuale errore restituito */
+    error: string;
+    /** ID dell'eventuale entità relativa a questa risposta */
+    entityid: any;
+    /** Indica se ci sono warning */
+    haswarning: boolean;
+    /** Log dell'eventuale warning restituito */
+    warning: string;
+    /** Entità collegata a questo CallResult */
+    entity: T;
+}

package/lib/models/CsvHeaders.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Header per il file CSV che sta venendo generato
+ */
+export declare class CsvHeaders {
+    /**
+     * Intestazione della colonna
+     */
+    label: string;
+    /**
+     * Nome della proprietà visualizzata in questa colonna
+     */
+    key: string;
+    /**
+     * Ordine della colonna
+     */
+    order: number;
+    /**
+     * Nome della chiave della proprietà lato es-table
+     */
+    propKey: string;
+    /**
+     * Tipo della colonna (per eventuali formattazioni se si scarica in Excel)
+     */
+    type: 'string' | 'number' | 'date';
+}

package/lib/models/ExportConsts.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Suffisso della proprietà da generare in cui salvare il navigatore
+ * utilizzato dal servizio di esportazione per prendere il valore delle proprietà di un oggetto
+ */
+export declare const csvValueNavigator: string;
+/** Suffisso con le informazioni del tipo per le esportazioni di oggetti */
+export declare const csvValueType: string;
+/** Suffisso della proprietà da generare in cui salvare l'ordine di esportazione */
+export declare const csvOrdPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare la visibilità di questa proprietà */
+export declare const csvVisPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare il nome della colonna in cui salvare questa proprietà */
+export declare const csvHdrPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare il codice del th a cui si riferisce questo campo */
+export declare const csvPropKey: string;
+/** Suffisso della proprietà da generare in cui salvare il valore da prendere per una proprietà di tipo Lista */
+export declare const listCsvValPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare l'Header della proprietà di tipo Lista relativo al valore esportato nella proprietà con suffisso **listCsvValPrefix** */
+export declare const listCsvHdrPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare il formato della proprietà di tipo Lista relativo al valore esportato nella proprietà con suffisso **listCsvValPrefix** */
+export declare const listCsvValFormat: string;
+/** Suffisso della proprietà da generare in cui salvare il valore da prendere per una proprietà di tipo Dizionario */
+export declare const dictionaryCsvValPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare l'Header della proprietà di un Dizionario relativo al valore esportato nella proprietà con suffisso **dictionaryCsvValPrefix** */
+export declare const dictionaryCsvHdrPrefix: string;
+/** Suffisso della proprietà da generare in cui salvare il formato della proprietà che si sta esportando */
+export declare const csvFormatPrefix: string;
+/** Nome della proprietà che contiene tutti i nomi di tutte le proprietà da esportare */
+export declare const exportList: string;
+/** Nome della proprietà che contiene la classe di localizzazione da utilizzare per una data esportazione */
+export declare const locProperty: string;

package/lib/models/ExtensionsModuleConfig.d.ts

@@ -0,0 +1,9 @@
+/** Classe di configurazione per il modulo di estensione */
+export declare class ExtensionsModuleConfig {
+    /** Indica se i metodi di estensione che utilizzano le date permettono l'uso di date in utc */
+    allow_utc?: boolean;
+    /** Prefisso delle searchView che serve per storicizzarle evitando di tirarsi in memoria anche tutti gli oggetti. Se vuoto viene supposto 'Hot' */
+    appsearch_prefix?: string;
+    /** Attiva la modalità di debug per l'esposizione di messaggi significativi */
+    debugMode?: boolean;
+}

package/lib/models/GenericItem.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rappresentazione di un oggetto generico
+ */
+export declare class GenericItem {
+    /**
+     * Dizionario Chiave - Valore delle proprietà di questo oggetto generico
+     */
+    properties: Record<string, string>;
+}

package/lib/models/InboundMessageTypes.d.ts

@@ -0,0 +1,5 @@
+/** Enumeratore dei tipi di messaggio che i moduli esterni possono contattare sull'applicazione principale */
+export declare enum InboundMessageTypes {
+    /** Evento di navigazione */
+    Navigation = 0
+}

package/lib/models/InterComMessage.d.ts

@@ -0,0 +1,12 @@
+/** Classe che rappresenta un generico messaggio scambiato fra applicazione e moduli */
+export declare class InterComMessage {
+    type: any;
+    message: any;
+    /**
+     * Costruttore
+     *
+     * @param type Tipo di messaggio
+     * @param message Contenuto del messaggio
+     */
+    constructor(type: any, message: any);
+}

package/lib/models/TypeCode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Mappatura del TypeCode del C#
+ */
+export declare enum TypeCode {
+    /** @ignore */ Empty = 0,
+    /** @ignore */ Obj = 1,
+    /** @ignore */ DBNull = 2,
+    /** @ignore */ Boolean = 3,
+    /** @ignore */ Char = 4,
+    /** @ignore */ SByte = 5,
+    /** @ignore */ Byte = 6,
+    /** @ignore */ Int16 = 7,
+    /** @ignore */ UInt16 = 8,
+    /** @ignore */ Int32 = 9,
+    /** @ignore */ UInt32 = 10,
+    /** @ignore */ Int64 = 11,
+    /** @ignore */ UInt64 = 12,
+    /** @ignore */ Single = 13,
+    /** @ignore */ Double = 14,
+    /** @ignore */ Decimal = 15,
+    /** @ignore */ DateTime = 16,
+    /** @ignore */ String = 18
+}

package/lib/modules/extensions.module.d.ts

@@ -0,0 +1,11 @@
+import { ModuleWithProviders } from '@angular/core';
+import { ExtensionsModuleConfig } from '../models/ExtensionsModuleConfig';
+import * as i0 from "@angular/core";
+import * as i1 from "../pipes/loc_date.pipe";
+import * as i2 from "@esfaenza/localizations";
+export declare class ExtensionsModule {
+    static forRoot(config?: ExtensionsModuleConfig): ModuleWithProviders<ExtensionsModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtensionsModule, [typeof i1.LocDatePipe], [typeof i2.LocalizationModule], [typeof i1.LocDatePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExtensionsModule>;
+}

package/lib/pipes/loc_date.pipe.d.ts

@@ -0,0 +1,24 @@
+import { PipeTransform } from "@angular/core";
+import { DateService } from "../services/extensions.dates.service";
+import * as i0 from "@angular/core";
+/**
+ * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
+ */
+export declare class LocDatePipe implements PipeTransform {
+    private dts;
+    /**
+     * @ignore
+     */
+    constructor(dts: DateService);
+    /**
+     * Trasformazione della data in input in base al formato richiesto
+     *
+     * @param {any} value Valore da ricondurre ad una data e formattare
+     * @param {string} format Formato in output della data da visualizzare
+     *
+     * @returns {string} Data formattata in base al formato
+     */
+    transform(value: any, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocDatePipe, "loc_date", false>;
+}

package/lib/services/extensions.base.d.ts

@@ -0,0 +1,22 @@
+import { AppEmbeddingExtensions } from "./extensions.embedding.service";
+import * as i0 from "@angular/core";
+/**
+ * WIP: per razionalizzare il fill della routesmap (vedi CRM app.extensions.ts)
+ */
+export declare class BaseExtensionsService {
+    private emb;
+    RedirectMap: {
+        [index: string]: {
+            url: string;
+            params: string[];
+        };
+    };
+    RoutesMap: {
+        [index: string]: {
+            route: (param: string) => any;
+        };
+    };
+    constructor(emb: AppEmbeddingExtensions);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseExtensionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseExtensionsService>;
+}

package/lib/services/extensions.clipboard.service.d.ts

@@ -0,0 +1,55 @@
+import { BaseLocalization } from "@esfaenza/localizations";
+import { MessageService } from './extensions.messages.service';
+import * as i0 from "@angular/core";
+/**
+ * Service che fornisce un accesso base in lettura/scrittura sulla clipboard
+ */
+export declare class ClipboardService {
+    private msgService;
+    private locProvider;
+    /**
+     * Oggetto statico di localizzazione per i messaggi di questa Service
+     */
+    private loc;
+    private isBrowser;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(msgService: MessageService, locProvider: BaseLocalization, platformId: Object);
+    /**
+     * Prende il valore della clipboard.
+     * Si può specificare se ci si aspetta una lista o una matrice di valori in modo da ricevere già un risultato utilizzabile
+     *
+     * @param {'array' | 'matrix'} style Stile dell'output desiderato, se array o matrice
+     * @param {Function} valueFoundCallback Callback che questa funzione chiamerà una volta ottenuto i valori richiesti dalla clipboard
+     */
+    getClipboard(style: 'array' | 'matrix', valueFoundCallback: (values: string[] | string[][]) => void): Promise<void>;
+    /** @ignore */
+    private doClipboardDataGet;
+    /**
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline)
+     *
+     * @param {string} data contenuto letto dalla clipboard
+     *
+     * @returns {string[]} Array contenente il testo preso dalla clipboard diviso per riga
+     */
+    private getClipboardLines;
+    /**
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline) e colonne (separate da tab)
+     *
+     * @param {string} data contenuto letto dalla clipboard
+     *
+     * @returns {string[][]} Matrice contenente il testo preso dalla clipboard diviso per riga e colonna
+     */
+    private getClipboardMatrix;
+    /**
+     * Metodo che copia un testo all'interno della clipboard
+     *
+     * @param {string} text Testo da inserire nella clipboard
+     */
+    copyTextToClipboard(text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, [null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}

package/lib/services/extensions.dates.service.d.ts

@@ -0,0 +1,103 @@
+import { BaseLocalization } from "@esfaenza/localizations";
+import { ReplaySubject } from "rxjs";
+import * as i0 from "@angular/core";
+/**
+* Service che fornisce dei metodi di estensione per la gestione/manipolazione delle date
+*/
+export declare class DateService {
+    private locProvider;
+    private allowUtc;
+    Initialized: ReplaySubject<void>;
+    /**
+     * Oggetto statico di localizzazione per i messaggi di questa Service
+     */
+    private loc;
+    /**
+     * Oggetto di configurazione per tenere da conto le informazioni sui formati
+     */
+    private cfg;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(locProvider: BaseLocalization, allowUtc: boolean);
+    init(): Promise<void>;
+    /**
+     * Aggiusta una data in "istante finale" in base a qual è la parte di data significativa.
+     *
+     * Es. Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
+     *
+     * @param {any} date Data qualsiasi (Date, stringa, dayjs...), verrà ricondotta ad un oggetto dayJs
+     * @param {'day' | 'hour' | 'minute'} timepart Parte significativa della data
+     * @param {boolean} printSeconds Indica se effettuare la stampa dei secondi o no
+     */
+    adjustDateToFinalInstant(date: any, timepart: 'day' | 'hour' | 'minute', printSeconds?: boolean): string;
+    /**
+     * Funzione che effettua l'ordinamento fra 2 date in base alla direzione specificata
+     *
+     * @param {any} a Prima data per il confronto
+     * @param {any} b Seconda data per il confronto
+     * @param {'asc' | 'desc'} direction Direzione rispetto a cui ordinare le due date
+     *
+     * @returns {number} 0 se le date sono uguali, 1 se la data A deve venire logicamente prima della data B, -1 altrimenti
+     */
+    dateSort(a: any, b: any, direction: 'asc' | 'desc'): number;
+    /**
+     * Effettua il trim dei secondi da una data espressa come stringa
+     *
+     * @param {string} value Data espressa come stringa
+     *
+     * @returns {string} Data senza i secondi
+     */
+    trimSeconds(value: string): string;
+    /**
+     * Data una lista di date Da e una lista di date A restituisce un oggetto rappresentante il range che include tutte le date passate
+     *
+     * @param {any[]} fromDates Lista dei Da
+     * @param {any[]} toDates Lista dei A
+     *
+     * @returns {{ from: any, to: any }} Range di date Da - A che include tutti i valori di **fromDates** e **toDates**
+     */
+    getMinMaxDatesRange(fromDates: any[], toDates: any[]): {
+        from: any;
+        to: any;
+    };
+    /**
+     * Ottiene la conversione di una data in qualsiasi formato al formato standard DayJs
+     *
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} useUtc Indica se usare l'estensione utc di Dayjs per parsare la data o no
+     * @param {string} format formato in cui emettere la conversione
+     *
+     * @returns {any} Data in modalità {format}
+     */
+    getDateConvertion(date: any, useUtc?: boolean, format?: 'date' | 'timestring' | 'dayjs', timestringSmall?: boolean): any;
+    private formattedDayjs;
+    /**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse una data vera e propria, **false** altrimenti
+     *
+     * @param {any} check Oggetto da controllare
+     *
+     * @returns {boolean} Indicazione se l'oggetto è un vero Date di Javascript o no
+     */
+    private isJsDate;
+    /**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse un DayJs vero e proprio, **false** altrimenti
+     *
+     * @param {any} check Oggetto da controllare
+     * @returns {boolean} Indicazione se l'oggetto è un vero DayJs o no
+     */
+    private isDayJs;
+    /**
+     * Ottiene la formattazione di una data in base alla versione richiesta "small" o "long" e a se stampare o meno i secondi
+     *
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} small Indica se formattarla con un formato breve (se **true**) o un formato più lungo (se **false**)
+     *
+     * @returns {string} Data formattata nel formato richiesto
+     */
+    getFormatted(date: any, small: boolean, seconds: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateService, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateService>;
+}

package/lib/services/extensions.embedding.service.d.ts

@@ -0,0 +1,35 @@
+import { Location } from "@angular/common";
+import { Router } from "@angular/router";
+import { MessageService } from "./extensions.messages.service";
+import { ReplaySubject, Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class AppEmbeddingExtensions {
+    private msgService;
+    private router;
+    private location;
+    sidebarWidth: number;
+    EmbeddingSource: ReplaySubject<string>;
+    Embedded: boolean;
+    EmbeddingLevel: number;
+    MainWindow: any;
+    MessageObserver: Subject<{
+        event: any;
+        data: any;
+    }>;
+    private _reloadAllowed;
+    EmbeddedModule: string;
+    private pushedHistories;
+    private isBrowser;
+    constructor(msgService: MessageService, router: Router, location: Location, platformId: Object);
+    private waitForMyConfigAndForceEmbeddedModule;
+    IsReloadAllowed(): boolean;
+    private MessageBarrierDebouncMs;
+    private OnMessageCallBarrier;
+    private messageHash;
+    configureEmbeddability(): void;
+    private onNavigateBack;
+    replaceState(basePath: string, url: string): void;
+    refreshBoundariesOnMenuCollapse(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEmbeddingExtensions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppEmbeddingExtensions>;
+}

package/lib/services/extensions.exports.service.d.ts

@@ -0,0 +1,242 @@
+import { Type } from "@angular/core";
+import { LocalizationService } from "@esfaenza/localizations";
+import { DateService } from './extensions.dates.service';
+import { UtilityService } from "./extensions.utilities.service";
+import { CsvHeaders } from "../models/CsvHeaders";
+import { GenericItem } from "../models/GenericItem";
+import * as i0 from "@angular/core";
+/**
+ * Decoratore che fornisce la classe di localizzazione per tutte le proprietà esportate con @Export e qualsiasi altro tag che richieda localizzazioni.
+ *
+ * Sostanzilamente aggiunge la proprietà **__loc__** all'oggetto creato dalla classe corrente assegnandogli come valore il tipo del LocalizationService da usare per la traduzione
+ *
+ * @param {Type<LocalizationService>} loc Tipo ereditato dal LocalizationService che può essere creato a runtime sotto contesto della DI di Angular
+ */
+export declare function ExportLocalization(loc: Type<LocalizationService>): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => {
+    new (...args: any[]): {
+        __loc__: Type<LocalizationService>;
+    };
+} & T;
+/**
+ * Decoratore di esportazione utilizzabile su una proprietà singola.
+ * Verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
+ *
+ * Ad esempio, da questa configurazione:
+ *
+ * @example
+ * ```
+ * @Export(true, "MyHeader")
+ * ciao: string;
+ * ```
+ *
+ * Nasceranno le seguenti proprietà nell'oggetto esportabile:
+ *
+ * @example
+ * ```
+ * ciao_csvvis: string; => true
+ * ciao: string;
+ * ciao_csvhdr: string => "MyHeader"
+ * ```
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} header Titolo della colonna nel file CSV esportato
+ * @param {string} format Formato di esportazione. Può essere un formato data per i campi data o 'F' per i campi floating point
+ */
+export declare const Export: (order: number, header: string, format?: string, tableid?: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Decoratore di esportazione utilizzabile su un oggetto.
+ * Per ogni proprietà dell'oggetto verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
+ * Per essere esportate, le proprietà dell'oggetto devono essere marcate con i Decoratori di esportazione
+ *
+ * Ad esempio, da questa configurazione:
+ *
+ * @example
+ * ```
+ * MyObj {
+ *     @Export(true, "MyHeader")
+ *     ciao: string;
+ * }
+ *
+ * @ExportObject(true, "MyHeader")
+ * test: MyObj;
+ * ```
+ *
+ * Nasceranno le seguenti proprietà nell'oggetto esportabile:
+ *
+ * @example
+ * ```
+ * testciao: string; => Valore di MyObj.ciao
+ * testciao_csvvis: string; => true
+ * testciao_csvhdr: string => "MyHeader"
+ * ```
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {any} type Tipo da esportare
+ */
+export declare const ExportAs: (order: number, type: any, prefix?: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Decoratore di esportazione utilizzabile su una lista,
+ * si utilizzano 2 navigator rispettivamente per la valorizzazione dell'Header e del Valore e
+ * per ogni elemento dell'array verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr)
+ *
+ * ATTENZIONE: Gli oggetti esportati in questa modalità non devono presentare altri tag di tipo @Export{...} all'interno. Fa tutto questo decoratore
+ *
+ * I navigator hanno questa convenzione:
+ *
+ * . --> divide due proprietà da richiamare consecutivamente: "a.b" richiamerà "obj.a.b";
+ *
+ * | --> divide più proprietà per le concatenazioni con uno spazio fra una e l'altra: "regdesc|slice.slicename" diventerà obj.regdesc + " " + obj.slice.slicename
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna
+ * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna
+ * @param {string} valueformat Formato di esportazione per i valori selezionati dal **valuenavigator**. Può essere un formato data per i campi data o 'F' per i campi floating point
+ */
+export declare const ExportList: (order: number, headernavigator: string, valuenavigator: string, valueformat?: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Decoratore di esportazione utilizzabile su un dizionario. Se ad esempio si vogliono generare le colonne
+ *
+ * Valore A = 1
+ *
+ * Valore B = 2
+ *
+ * Valore C = 3
+ *
+ * partendo da un oggetto iniziale { Valore { A: 1, B: 2, C: 3 } }
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} headerprefix Prefisso per l'header
+ * @param {string} valueprefix Prefisso per il valore
+ */
+export declare const ExportDictionary: (order: number, headerprefix: string, valueprefix: string) => (target: Object, propertyKey: string) => void;
+/**
+ * Service che si occupa dell'esportazione degli oggetti marcati dai Decoratori **ExportDictionary**, **ExportList**, **ExportAs** o **Export**
+ */
+export declare class ExportService {
+    private dates;
+    private utiExts;
+    private lc;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(dates: DateService, utiExts: UtilityService, lc: LocalizationService);
+    /**
+     * Data una lista di oggetti genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * @param {any[]} objs Oggetti da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    setupForExport(objs: any[], columns?: string[]): CsvHeaders[];
+    /**
+     * Data una lista di oggetti generici genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * @param {GenericItem[]} objs Oggetti generici da esportare
+     * @param {CsvHeaders[]} columns Colonne richieste dall'esportazione
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    setupForGenericExport(objs: GenericItem[], columns: CsvHeaders[]): CsvHeaders[];
+    /**
+     * Dato un oggetto generico genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * Metodo interno richiamato da **setupForGenericExport**
+     *
+     * @param {GenericItem} obj Oggetto generico da esportare
+     * @param {CsvColumn[]} columns Colonne richieste dall'esportazione
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    private parseAndGetGenericHeaders;
+    /**
+     * Dato un oggetto genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * Metodo interno richiamato da **setupForExport**
+     *
+     * @param {any} obj Oggetto generico da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    private parseAndGetHeaders;
+    /**
+     * Setup per l'esportazione di una singola proprietà.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    private parseProperty;
+    /**
+     * Setup per l'esportazione di una singola proprietà da un oggetto.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no.
+     *
+     * Per ottenere il valore e l'header della proprietà vengono utilizzati i navigatori auto-generati nel decoratore **ExportAs**
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    private parseObject;
+    /**
+     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
+     *
+     * => Recupero il valore utilizzando i navigatori
+     *
+     * => Recupero l'header utilizzando i navigatori
+     *
+     * => Con il valore ci creo la property
+     *
+     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    private parseList;
+    /**
+     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
+     *
+     * => Recupero il valore utilizzando i navigatori
+     *
+     * => Recupero l'header utilizzando i navigatori
+     *
+     * => Con il valore ci creo la property
+     *
+     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     */
+    private parseDictionary;
+    /**
+     * Effettua l'esportazione in file CSV
+     */
+    private exportCSV;
+    private exportCSVBuffer;
+    /** Effettua l'esportazione del file Excel basandosi sul modulo **ExcelJS**, sugli header **headers** e sui dati **data** */
+    private exportExcel;
+    private exportExcelBuffer;
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    export(items: any[], format: 'CSV' | 'XLSX', fileName: string, type: Type<any>, columnsFilter?: string[], genericHeaders?: CsvHeaders[]): CsvHeaders[];
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    exportBuffer(items: any[], format: 'CSV' | 'XLSX', fileName: string, type: Type<any>, columnsFilter?: string[], genericHeaders?: CsvHeaders[]): Uint8Array;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportService>;
+}