@eqproject/eqp-dynamic-module 0.0.1

package/lib/components/exported/eqp-dynamic-module-configurator/eqp-dynamic-module-configurator.component.d.ts

@@ -0,0 +1,186 @@
+import { EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { ConfigColumn, EqpTableComponent } from '@eqproject/eqp-table';
+import { BaseField } from '../../../models/baseField.model';
+import { Context } from '../../../models/context.model';
+import { ActionOnRecord, Form, FormScalarTypeEnum, FormTypeEnum } from '../../../models/form.model';
+export declare class EqpDynamicModuleConfiguratorComponent implements OnInit {
+    private formBuilder;
+    private dialog;
+    context: Context;
+    form: Form;
+    innerFormManagment: boolean;
+    formFormGroup: FormGroup;
+    formCompleted: boolean;
+    previewForm: Form;
+    formFieldGroupName: string;
+    actionAutocompleteOptions: Array<{
+        label: string;
+        value: string;
+    }>;
+    FormTypeEnum: typeof FormTypeEnum;
+    FormScalarTypeEnum: typeof FormScalarTypeEnum;
+    fieldsColumns: Array<ConfigColumn>;
+    fieldsTable: EqpTableComponent;
+    selectedField: BaseField | any;
+    indexSelectedField: number;
+    actionOnRecordFormGroup: FormGroup;
+    dialogFieldRef: MatDialogRef<TemplateRef<any>>;
+    dialogField: TemplateRef<any>;
+    fieldSectionColumnTemplate: TemplateRef<any>;
+    selectedInnerForm: Form;
+    indexSelectedInnerForm: number;
+    dialogInnerFormRef: MatDialogRef<TemplateRef<any>>;
+    dialogInnerForm: TemplateRef<any>;
+    actionsOnRecordColumns: Array<ConfigColumn>;
+    actionsOnRecordTable: EqpTableComponent;
+    selectedAction: ActionOnRecord;
+    indexSelectedAction: number;
+    dialogActionOnRecordRef: MatDialogRef<TemplateRef<any>>;
+    dialogActionOnRecord: TemplateRef<any>;
+    saveFormEvent: EventEmitter<Form>;
+    constructor(formBuilder: FormBuilder, dialog: MatDialog);
+    ngOnInit(): void;
+    /**
+     * Metodo invocato al cambio del tipo di visualizzazione della form.
+     * Se l'utente sceglie una visualizzazione raggruppata il metodo aggiunge al FormGroup un nuovo
+     * controllo per l'array dei nomi delle sezioni da creare.
+     */
+    onChangeFormScalarType(): void;
+    /**
+     * Evento invocato al keyup nell'input per inserire i nomi delle sezioni per la visualizzazione
+     * raggruppata della form. Quanto l'utente preme il tasto invio viene aggiunto il nuovo nome alle
+     * sezioni dispobili se non ne esiste una con lo stesso nome.
+     * @param event Evento che rappresenta il keyup sulla tastiera.
+     */
+    onFormFieldGroupNameKeyUp(event: any): void;
+    /**
+     * Metodo per rimuovere la sezione selezionata da quelle disponibili per la form.
+     * @param groupName Nome della sezione da eliminare.
+     */
+    onDeleteFormFieldGroupName(groupName: string): void;
+    /**
+     * Metodo chiamato quando si vuole aggiungere un nuovo campo o si vuole modificare uno esistente.
+     * Memorizza l'eventuale Field scelto one crea uno nuovo prima di aprire il dialog per modificarlo/aggiungerlo.
+     * @param field Oggetto BaseField da modificare. Se null ne viene creata una nuova istanza per l'aggiunta.
+     */
+    openFieldDialog(field?: BaseField): void;
+    /**
+     * Metodo che salva il campo appena creato o modificato.
+     * Prima del salvataggio controlla se esiste un altro campo con la stessa label, in questo
+     * case genere un errore (i campi devono avere nomi, e quindi label, univoche - i nomi vengono
+     * ricavati unendo le parole che formano la label tramite "_").
+     * @param field Campo da salvare
+     */
+    onSaveField(field: BaseField): void;
+    /**
+     * Metodo che controlla se lo step per l'aggiunta dei campi nella form è concluso.
+     * @returns Se TRUE lo step viene considerato completato ed è possbile passare al successivo.
+     */
+    isFieldStepCompleted(): boolean;
+    /**
+     * Metodo per aprire il dialog di creazione/modifica delle form di dettaglio.
+     * Se il parametro passato è null sono in aggiunta altrimenti sono in modifica.
+     * @param innenrForm Form di dettaglio da modificare (se null allora vado in add).
+     */
+    openInnerFormDialog(innenrForm?: Form): void;
+    /**
+     * Metodo scatenato al salvataggio di una form di dettaglio.
+     * @param event Form creata/modificata dall'utente. Se è null allora l'utente ha abbandonato la configurazione.
+     */
+    onSaveOrExitInnerForm(event: Form): void;
+    /**
+     * Metodo per aprire il dialog di creazione/modifica delle action.
+     * Se il parametro passato è null sono in aggiunta altrimenti sono in modifica.
+     * @param action ActionOnRecord da modificare (se null allora vado in add).
+     */
+    openActionOnRecordDialog(action?: ActionOnRecord): void;
+    /**
+     * Metodo per impostare i valori da suggerire nell'autocomplete del campo Formula.
+     * Viene scatenato al focus (in questo caso viene passato il parametro a null per differenziarlo
+     * dall'evento di click sulla tastiera) e al keyup sull'input (il parametro è diverso da null).
+     * @param keyboardEvent Evento scatenato al keyup sulla tastiera. Se null allora il metodo è stato invocato dal focus sull'input.
+     * @summary Aggiorna l'elenco dei suggerimenti per l'autocomplete se l'utente esegue il focus sull'input
+     * oppure al keyup sulla tastiera di un tasto diverso dalle frecce.
+     */
+    setActionAutocompleteOptions(keyboardEvent: KeyboardEvent): void;
+    /**
+     * Metodo per salvare l'azione creata/modificate.
+     */
+    saveActionOnRecord(): void;
+    /**
+     * Metodo per chiudere il dialog di gestione delle action.
+     */
+    closeDialogActionOnRecord(): void;
+    /**
+     * Metodo per segnare come conclusa la creazione della form e per crearne una copia
+     * da visalizzare come anteprima.
+     * @param completed Se TRUE segna la form come conclusa e ne crea una copia da visualizzare
+     */
+    setFormStatus(completed: boolean): void;
+    /**
+     * Metodo che scatena l'evento di output per salvare la form creata alla fine del wizard
+     */
+    saveForm(): void;
+    /**
+     * Configura le colonne per le tabelle necessarie alla creazione della form:
+     *  - per la visualizzazione dei campi inseriti
+     *  - per le form di dettaglio create
+     *  - per le azioni configurate sui record della form
+     */
+    private configureColumns;
+    /**
+     * Crea il FormGroup per l'oggetto Form
+     */
+    private createFormForm;
+    /**
+     * Crea il FormGroup epr l'aggiunta o la modifica di una action sui record della Form.
+     */
+    private createActionOnRecordForm;
+    /**
+     * Chiude il dialog per aggiungere/modificare un Field senza salvare
+     */
+    private closeFieldDialog;
+    /**
+     * Metodo per gestire l'apertura del dialog per la modifica di un Field.
+     * Se il field è di tipo "Form di dettaglio" apre il dialog per la modifica di una
+     * InnerForm altrimenti apre quello per la modifica di un Field.
+     * @param field Campo da modificare
+     */
+    private editField;
+    /**
+     * Metodo per rimuovere un Field all'interno di una Form.
+     * Richiede conferma all'utente prima di rimuoverlo.
+     * @param field BaseField da rimuovere
+     */
+    private deleteElement;
+    /**
+     * Metodo per spostare un campo all'interno della form.
+     * @param field Oggetto di tipo BaseField da spostare.
+     * @param moveUp Se TRUE allora sposta verso l'alto il campo (abbassa l'indice) altrimenti il contrario.
+     */
+    private moveElement;
+    /**
+     * Imposta l'ordinamento delle sezioni che compongono la form.
+     */
+    private setFormFieldGroupOrdinalPosition;
+    /**
+     * Imposta l'ordinamento dei campi all'interno della form in base all'ordine che l'utente
+     * ha definito nella tabella in cui sono mostrati
+     */
+    private setFieldOrdinalPosition;
+    /**
+     * Metodo per ricaricare i dati della tabella dei campi aggiunti in una form
+     */
+    private reloadFieldsTable;
+    /**
+     * Imposta l'ordinamento dei campi all'interno della form in base all'ordine che l'utente
+     * ha definito nella tabella in cui sono mostrati
+     */
+    private setActionOrdinalPosition;
+    /**
+     * Metodo per ricaricare i dati della tabella delle azioni aggiuntive sui record della Form.
+     */
+    private reloadActionsOnRecordTable;
+}

package/lib/components/private/add-form-field/add-form-field.component.d.ts

@@ -0,0 +1,160 @@
+import { EventEmitter, OnInit, TemplateRef } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { EnumHelper } from '@eqproject/eqp-select';
+import { ConfigColumn, EqpTableComponent } from '@eqproject/eqp-table';
+import { BaseField, ColSpanSizesEnum, FieldTypeEnum } from '../../../models/baseField.model';
+import { BoolPresentantioEnum } from '../../../models/fields/booleanField.model';
+import { DateTimeTypeEnum } from '../../../models/fields/dateField.model';
+import { ListPresentationEnum } from '../../../models/fields/listValueField.model';
+import { FormFieldGroup } from '../../../models/form.model';
+export declare class AddFormFieldComponent implements OnInit {
+    private formBuilder;
+    private enumHelper;
+    private dialog;
+    field: BaseField | any;
+    indexField: number;
+    formFieldsGroups: Array<FormFieldGroup>;
+    /** Elenco dei Field creati nella form, usati per popolare l'autocomplete della proprietà Formula. */
+    availableFields: Array<BaseField>;
+    fieldTypesToExclude: Array<FieldTypeEnum>;
+    fieldFormGroup: FormGroup;
+    keyValueObject: {
+        key: string;
+        value: string;
+    };
+    availableColSpanSizes: Array<ColSpanSizesEnum>;
+    formulaAutocompleteOptions: Array<{
+        label: string;
+        value: string;
+    }>;
+    AvailableFileExtensions: {
+        key: string;
+        value: string;
+    }[];
+    AvailableImageExtensions: {
+        key: string;
+        value: string;
+    }[];
+    saveFieldEvent: EventEmitter<BaseField | any>;
+    fieldTypeFormTemplate: TemplateRef<any>;
+    textFieldFormTemplate: TemplateRef<any>;
+    textareaFieldFormTemplate: TemplateRef<any>;
+    booleadFieldFormTemplate: TemplateRef<any>;
+    dateFieldFormTemplate: TemplateRef<any>;
+    numericFieldFormTemplate: TemplateRef<any>;
+    attachmentFieldFormTemplate: TemplateRef<any>;
+    imageFieldFormTemplate: TemplateRef<any>;
+    listValueFieldFormTemplate: TemplateRef<any>;
+    lookupFieldFormTemplate: TemplateRef<any>;
+    metadataColumns: Array<ConfigColumn>;
+    metadataFieldsTable: EqpTableComponent;
+    selectedMetadata: BaseField;
+    indexSelectedMetadata: number;
+    dialogMetadataRef: MatDialogRef<TemplateRef<any>>;
+    dialogMetadata: TemplateRef<any>;
+    FieldTypeEnum: typeof FieldTypeEnum;
+    BoolPresentantioEnum: typeof BoolPresentantioEnum;
+    DateTimeTypeEnum: typeof DateTimeTypeEnum;
+    ListPresentationEnum: typeof ListPresentationEnum;
+    constructor(formBuilder: FormBuilder, enumHelper: EnumHelper, dialog: MatDialog);
+    ngOnInit(): void;
+    /**
+     * Metodo per impostare i valori da suggerire nell'autocomplete del campo Formula.
+     * Viene scatenato al focus (in questo caso viene passato il parametro a null per differenziarlo
+     * dall'evento di click sulla tastiera) e al keyup sull'input (il parametro è diverso da null).
+     * @param keyboardEvent Evento scatenato al keyup sulla tastiera. Se null allora il metodo è stato invocato dal focus sull'input.
+     * @summary Aggiorna l'elenco dei suggerimenti per l'autocomplete se l'utente esegue il focus sull'input
+     * oppure al keyup sulla tastiera di un tasto diverso dalle frecce.
+     */
+    setFormulaAutocompleteOptions(keyboardEvent: KeyboardEvent): void;
+    /**
+     * Crea il FormGroup per l'aggiunta di un nuovo campo all'interno della form.
+     * Metodo richiamato ogni volta che cambia il tipo del campo scelto o viene aggiunto/modificato un Field
+     */
+    createFieldForm(): void;
+    /**
+     * Metodo chiamato quando cambia il FieldType del BaseField che si sta aggiungendo/modificando.
+     * Ricrea l'oggetto field popolando solo le proprietà del BaseField inserite dall'utente
+     * (quelle comuni a tutte le tipologie di campo), ricrea la form e, in base al FieldType scelto,
+     * aggiunge alla form i FormControl necessari e seleziona il template corretto da usare.
+     * @param restoreField Se TRUE ripristina i valori base (ereditati dal modello BaseField) del campo aggiunto/modificato
+     */
+    onFieldTypeChange(restoreField?: boolean): void;
+    /**
+     * Metodo invocato alla selezione di una classe nella select per le colonne di bootstrap
+     * da usare nella visualizzazione del campo. Questa funzione manipola la sorgente dati per
+     * la eqp-select in modo da escludere i valori dell'enumeratore che fanno riferimento ad
+     * una larghezza di schermo già selezionata. Esempio: per gli schermi piccoli (sm) l'utente
+     * seleziona la classe "col-sm-6", al change del valore questo metodo rimuove dalla select
+     * tutti gli altri valori per la grandezza di schermo selezionata.
+     */
+    onColSizeSelect(): void;
+    /**
+     * Metodo chiamato al keyup degli input testuali che prevedono l'aggiunta del valore inserito in un array.
+     * Se l'utente preme il tasto invio, in base al tipo di campo che sta inserendo/modificando, questo metodo
+     * aggiunge il valore inserito dall'utente nella lista di stringhe corretta (in input viene passato il nome
+     * della proprietà in cui inserire la stringa).
+     * @param event Evento che rappresenta il keyup dell'utente
+     * @param propertyName Nome della proprietà del field in cui inserire la stringa digitata.
+     */
+    onMultiSelectInputKeyup(event: any, propertyName: string): void;
+    /**
+     * Metodo chiamato per mostrare come elenco le opzioni aggiunte in un campo di tipo "Elenco generico".
+     * @returns Restituisce un array di oggetti del tipo { key: string, value: string } con i valori inseriti dall'utente.
+     */
+    getDictionaryKeyValue(): {
+        key: string;
+        value: any;
+    }[];
+    /**
+     * Metodo per rimuovere una opzione aggiunta al campo di tipo "Elenco generico"
+     * @param key Nome della chiave da rimuovere
+     */
+    deleteKeyFromDictionary(key: string): void;
+    /**
+     * Metodo per aprire il dialog per aggiungere/modificare un metadata in un campo di tipo Allegato o Immagine.
+     * @param metadata Metadata da modificare, se null allora ne sto creando uno nuovo.
+     */
+    openMetadataDialog(field?: BaseField): void;
+    /**
+     * Metodo invocato dall'output dal dialog per aggiungere/modificare un metadata
+     * nei campi di tipo Allegato o Immagine. Prima di aggiungere il metadata nell'elenco
+     * contolla se esiste un altro metadata con lo stesso nome e nel caso genera un errore
+     * (i metadata, come per i campi della form, devono avere un nome univoco).
+     * @param metadata Metadata aggiunto o modificato, se null allora il dialog è stato chiuso senza fare modifiche.
+     */
+    onSaveMetadata(metadata: BaseField): void;
+    /**
+     * Metodo per disabilitare il pulsante per salvare il campo inserito/modificato.
+     * @returns Restituisce un booleano, se true il salvataggio viene disabilitato.
+     */
+    disableSaveField(): boolean;
+    /**
+     * Metodo per salvare il campo inserito/modificato.
+     * Se è stato inserito un field con la stessa label viene generato un errore (le label devono essere univoche).
+     * Una volta aggiunto/aggiornato il campo nell'elenco dei Field della Form chiude il dialog e ricarica la tabella
+     * che mostra l'elenco dei campi aggiunti alla form.
+     */
+    saveAndExitAddField(save: boolean): void;
+    /**
+     * Metodo per ripristinare l'oggetto field al cambio del tipo selezionato.
+     * Lascia valorizzate solo le proprietà dell'oggetto BaseField comune a tutti i tipi di campo.
+     */
+    private restoreBaseFieldProperties;
+    private configureColumns;
+    /**
+     * Metodo per eliminare un metadata aggiunto per un campo di tipo Allegato o Immagine.
+     * @param metadata Metadata da eliminare.
+     */
+    private deleteMetadata;
+    /**
+     * Imposta l'ordinamento dei metadata all'interno dei campi di tipo Allegato e Immagine.
+     */
+    private setMetadataOrdinalPosition;
+    /**
+     * Metodo per ricaricare i dati della tabella dei metadata visualizzata nella creazione/modifica
+     * dei campi di tipo Allegato o Immagine.
+     */
+    private reloadMetadataTable;
+}

package/lib/components/private/dynamic-module-field/dynamic-module-field.component.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { IBaseFieldComponent } from '../../../interfaces/iBaseFieldComponent.interface';
+import { BaseField, FieldTypeEnum } from '../../../models/baseField.model';
+import { Form } from '../../../models/form.model';
+import { Record } from '../../../models/record.model';
+import { ListFormRecordComponent } from '../form-records/list-form-record/list-form-record.component';
+export declare class DynamicModuleFieldComponent implements OnInit, IBaseFieldComponent {
+    private dialog;
+    field: BaseField;
+    form: Form;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    FieldTypeEnum: typeof FieldTypeEnum;
+    selectedInnerForm: Form;
+    selectedInnerFormRecord: Record;
+    indexInnerFormRecord: number;
+    onlyViewInnerFormRecord: boolean;
+    dialogInnerFormRecordRef: MatDialogRef<TemplateRef<any>>;
+    dialogInnerFormRecord: TemplateRef<any>;
+    fieldTemplate: QueryList<DynamicModuleFieldComponent>;
+    listInnerFormRecords: QueryList<ListFormRecordComponent>;
+    constructor(dialog: MatDialog);
+    updateField(): void;
+    ngOnInit(): void;
+    /**
+     * Metodo invocato al cambio del valore di ogni proprietà dell'oggetto record.
+     * Serve ad aggiornare il valore di tutti i campi che hanno una formula.
+     */
+    onRecordChange(): void;
+    /**
+     * Metodo per recuperare una InnerForm a partire dal Field che la rappresenta.
+     * @param field Campo a partire dal quale si vuole recuperare la InnerForm.
+     * @returns Restituisce un oggetto di tipo Form.
+     */
+    getInnerFormFromField(field: BaseField): Form;
+    /**
+   * Metodo per aprire un dialog in cui aggiungere/modificare/visualizzare un record appartenente
+   * a una form di dettaglio.
+   * @param record Evento di output del componente list-form-record, contiene il record selezionato e un booleno che indica
+   * se l'utente vuole modificare o visualizzare l'elemento selezionato.
+   * @param innerForm Contiene la Form di dettaglio dalla quale è stato richiesto il record.
+   */
+    onAddViewEditInnerFormRecord(record: {
+        record: Record;
+        onlyView: boolean;
+    }, field: BaseField): void;
+    /**
+     * Metodo invocato al salvataggio o alla chiusura del dialog di aggiunta/modifica/visualizzazione
+     * di un record di una form di dettaglio.
+     * @param record Oggetto restituito dal componente add-form-field (questo qui) contenente il Record
+     * aggiornato dall'utente. Se null allora l'utente non ha modificato nulla e ha chiuso il dialog.
+     */
+    onSaveInnerFormRecord(record: Record): void;
+}

package/lib/components/private/field-templates/attachment-field-template/attachment-field-template.component.d.ts

@@ -0,0 +1,84 @@
+import { AfterViewInit, ChangeDetectorRef, EventEmitter, OnChanges, OnInit, SimpleChanges, TemplateRef } from '@angular/core';
+import { Record } from '../../../../models/record.model';
+import { AttachmentField } from '../../../../models/fields/attachmentField.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+import { UtilityHelperService } from '../../../../services/utilityHelper.services';
+import { EqpAttachmentsComponent } from '@eqproject/eqp-attachments';
+import { FormGroup } from '@angular/forms';
+import { ConfigColumn } from '@eqproject/eqp-table';
+export declare class AttachmentFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent, AfterViewInit {
+    utilityService: UtilityHelperService;
+    private cdr;
+    onlyImages: boolean;
+    field: AttachmentField;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    eqpAttachments: EqpAttachmentsComponent;
+    metadataColumnTemplate: TemplateRef<any>;
+    metadataFormGroups: Array<FormGroup>;
+    previewLabel: string;
+    emptyTableMessage: string;
+    downloadTooltipPosition: string;
+    openLinkLabel: string;
+    addButtonLabel: string;
+    downloadLabel: string;
+    deleteLabel: string;
+    fileNameLabel: string;
+    uploadFileLabel: string;
+    confirmLabel: string;
+    abortLabel: string;
+    saveLabel: string;
+    exitLabel: string;
+    eqpTableSearchText: string;
+    deleteDialogTitle: string;
+    deleteDialogMessage: string;
+    noImageSelectedErrorMessage: string;
+    constructor(utilityService: UtilityHelperService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+    /**
+     * Metodo per intercettare le modifiche agli allegati caricati.
+     * Se il campo prevede dei metadata allora per ogni allegato caricato crea un FormGroup
+     * per gestire la validazione degli input che l'utente può/deve riempire. I FormGroup
+     * seguono lo stesso ordine degli allegati caricati.
+     * @param event Contiene la lista aggiornata degli Attachment caricati dall'utente.
+     */
+    catchAttachmentList(event: any): void;
+    /**
+     * Metodo per aggiornare lo stato di validazione del FormControl che rappresenta
+     * il campo Allegato (non i metadata al suo interno). Se tra le form dei metadata
+     * ne trova una invalida allora marca il controllo come invalido.
+     */
+    updateMetadataValidity(): void;
+    /**
+     * Metodo per recuperare il BaseField che rappresenta il metadata nella riga della eqp-table
+     * in base alla colonna e alla riga. Una volta trovato il BaseField gli viene associato il
+     * FormGroup di cui fa parte.
+     * @param col Colonna della eqp-table.
+     * @param row Riga della eqp-table (in questo caso eredita da IAttachment).
+     * @returns Restituisce un BaseField per renderizzare il campo nella eqp-table degli allegati multipli.
+     */
+    getFieldFromMetadata(col: ConfigColumn, row: any): any;
+    /**
+     * Metodo per aggiornare il valore e il validator del FormControl associato al campo.
+     */
+    private setFormControlValue;
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    private onRecordValueChange;
+    /**
+     * Metodo per aggiungere alle colonne di eqp-attachments le colonne per modificare i metadata
+     * configurati per il campo Allegato o Immagine.
+     */
+    private configureMultiAttachmentColumns;
+    /**
+     * Metodo per creare i FormGroup che rappresentano i metadata degli allegati caricati.
+     */
+    private createMetadataFormGroups;
+}

package/lib/components/private/field-templates/boolean-field-template/boolean-field-template.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { Record } from '../../../../models/record.model';
+import { BooleanField, BoolPresentantioEnum } from '../../../../models/fields/booleanField.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+export declare class BooleanFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {
+    field: BooleanField;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    BoolPresentantioEnum: typeof BoolPresentantioEnum;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange(): void;
+}

package/lib/components/private/field-templates/date-field-template/date-field-template.component.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { PickerModeEnum } from '@eqproject/eqp-datetimepicker';
+import { Record } from '../../../../models/record.model';
+import { DateField } from '../../../../models/fields/dateField.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+export declare class DateFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {
+    field: DateField;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    pickerMode: PickerModeEnum;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange(): void;
+    /**
+     * In base al formato della data richiesta nel DateField (solo data, solo orario o data e ora)
+     * imposta la visualizzazione corretta del componente eqp-datetimepicker.
+     */
+    private setTimeType;
+}

package/lib/components/private/field-templates/image-field-template/image-field-template.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { ImageField } from '../../../../models/fields/imageField.model';
+import { Record } from '../../../../models/record.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+export declare class ImageFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {
+    record: Record;
+    field: ImageField;
+    recordChange: EventEmitter<Record>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+}

package/lib/components/private/field-templates/list-value-field-template/list-value-field-template.component.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { Record } from '../../../../models/record.model';
+import { ListPresentationEnum, ListValueField } from '../../../../models/fields/listValueField.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+export declare class ListValueFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {
+    field: ListValueField;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    ListPresentationEnum: typeof ListPresentationEnum;
+    arrayData: {
+        Key: string;
+        Value: any;
+        Selected?: boolean;
+    }[];
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+    /**
+     * Metodo per recuperare la classe da applicare al button (nella relativa visualizzazione).
+     * Se il pulsante è stato selezionato imposta la classe "selected-button".
+     * @param data Oggetto bindato al pulsante
+     * @returns Restituisce la classe da applicare tramite [ngClass]
+     */
+    getSelectButtonClass(data: {
+        Key: string;
+        Value: any;
+        Selected?: boolean;
+    }): string;
+    /**
+     * Metodo invocato quando viene selezionata un'opzione nella visualizzazione a button
+     * @param data Rappresenta l'oggetto selezionato
+     */
+    buttonSelectClick(data: {
+        Key: string;
+        Value: any;
+        Selected?: boolean;
+    }): void;
+    /**
+     * Metodo per aggiornare il/i valore/i selezionato/i dall'utente.
+     * @param emitChange Se true scatena l'evento di output della modifica del valore di record
+     */
+    updateSelected(emitChange?: boolean): void;
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange(): void;
+    /**
+     * Metodo per creare un array di oggetti del tipo { Key: string, Value: any } da usare come sorgente dati per la eqp-select.
+     */
+    private setArrayData;
+    /**
+     * Metodo per aggiornare il valore e il validator del FormControl associato al campo.
+     */
+    private setFormControlValue;
+}

package/lib/components/private/field-templates/numeric-field-template/numeric-field-template.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { NumericMaskConfig } from '@eqproject/eqp-numeric';
+import { Record } from '../../../../models/record.model';
+import { NumericField } from '../../../../models/fields/numericField.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+export declare class NumericFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {
+    field: NumericField;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    eqpNumericOptions: Partial<NumericMaskConfig>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange(): void;
+    /**
+     * Metodo per configurare eqp-numeric
+     */
+    private configureEqpNumericOptions;
+}

package/lib/components/private/field-templates/text-field-template/text-field-template.component.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { Record } from '../../../../models/record.model';
+import { TextField } from '../../../../models/fields/textField.model';
+import { IBaseFieldComponent } from '../../../../interfaces/iBaseFieldComponent.interface';
+export declare class TextFieldTemplateComponent implements OnInit, OnChanges, IBaseFieldComponent {
+    field: TextField;
+    record: Record;
+    recordChange: EventEmitter<Record>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Metodo per aggiornare il valore del campo quando questo è rappresentato da una formula.
+     */
+    updateField(): void;
+    /**
+     * Metodo per emettere l'evento che il valore del record è cambiato.
+     */
+    onRecordValueChange(): void;
+}