@gnggln/ng-ui-system 1.0.0-alpha.0

package/lib/components/crud-table/crud-table.component.d.ts

@@ -0,0 +1,143 @@
+import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { UiButtonDescriptor } from '../button/button.types';
+import { UiFormBuilderComponent } from '../form-builder/form-builder.component';
+import { UiFormData } from '../form-builder/types/schema.types';
+import { UiCrudTableColumn, UiCrudTableConfig, UiCrudMode, UiCrudEditEvent, UiCrudDeleteEvent } from './crud-table.types';
+import * as i0 from "@angular/core";
+/**
+ * Tabella CRUD standalone con form builder integrato.
+ *
+ * Gestisce il ciclo completo delle operazioni CRUD:
+ * inserimento, modifica, duplicazione, eliminazione e
+ * visualizzazione in sola lettura. Il form e generato
+ * automaticamente dallo schema `UiFormSchema`.
+ *
+ * Utilizza `UiModalService` per la conferma di eliminazione
+ * e `UiFormBuilderComponent` per la gestione del form.
+ *
+ * @selector ui-crud-table
+ *
+ * @example
+ * ```html
+ * <ui-crud-table
+ *   [data]="items"
+ *   [columns]="columns"
+ *   [config]="crudConfig"
+ *   (dataChange)="onDataChange($event)"
+ *   (itemAdd)="onAdd($event)"
+ *   (itemEdit)="onEdit($event)"
+ *   (itemDelete)="onDelete($event)"
+ * />
+ * ```
+ */
+export declare class UiCrudTableComponent<T extends Record<string, any> = Record<string, any>> implements OnInit, OnDestroy {
+    private readonly cdr;
+    private readonly modalService;
+    private readonly destroy$;
+    /** Array di dati da visualizzare nella tabella. */
+    data: T[];
+    /** Definizione delle colonne. */
+    columns: UiCrudTableColumn[];
+    /** Configurazione CRUD (schema form, permessi, label). */
+    config: UiCrudTableConfig;
+    /** Mostra l'overlay di caricamento. */
+    loading: boolean;
+    /** Disabilita tutte le azioni CRUD. */
+    disabled: boolean;
+    /**
+     * Funzione di mappatura applicata ai dati di un elemento
+     * prima di passarli come `initialData` al form builder.
+     * Utile per trasformare la struttura dati dell'oggetto.
+     */
+    initMapper?: (originalData: T) => Record<string, any>;
+    /** Emesso ogni volta che la lista dati cambia (insert/edit/duplicate). */
+    dataChange: EventEmitter<T[]>;
+    /** Emesso quando viene inserito un nuovo elemento. */
+    itemAdd: EventEmitter<T>;
+    /** Emesso quando viene modificato un elemento. */
+    itemEdit: EventEmitter<UiCrudEditEvent<T>>;
+    /** Emesso quando viene eliminato un elemento (dopo conferma). */
+    itemDelete: EventEmitter<UiCrudDeleteEvent<T>>;
+    /** Emesso quando viene duplicato un elemento. */
+    itemDuplicate: EventEmitter<T>;
+    /** Emesso quando l'utente clicca su una riga in modalita view. */
+    rowClick: EventEmitter<T>;
+    /** @internal Modalita corrente. */
+    currentMode: UiCrudMode;
+    /** @internal Elemento in fase di modifica/visualizzazione. */
+    editingItem: T | null;
+    /** @internal Indice dell'elemento in modifica. */
+    editingIndex: number | null;
+    /** @internal Dati originali dell'elemento prima della modifica. */
+    private lastOriginalData;
+    /** @internal Cache per i dati iniziali del form. */
+    private _formInitialData;
+    private _lastCacheKey;
+    /** @internal Riferimento al form builder. */
+    formBuilder: UiFormBuilderComponent;
+    /** @internal Pulsanti per il form. */
+    formButtons: UiButtonDescriptor[];
+    /** @internal Pulsante aggiungi. */
+    addButton: UiButtonDescriptor[];
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** La tabella e in modalita form (insert/edit/duplicate/readonly). */
+    get isFormMode(): boolean;
+    /** La tabella e in modalita sola lettura. */
+    get isReadonlyMode(): boolean;
+    /** Dati iniziali calcolati per il form builder. */
+    get formInitialData(): UiFormData;
+    /** Verifica se ci sono azioni disponibili (per mostrare la colonna azioni). */
+    hasAnyActions(): boolean;
+    /** Verifica se l'elemento puo essere modificato. */
+    canEditItem(item: any): boolean;
+    /** Verifica se l'elemento puo essere eliminato. */
+    canDeleteItem(item: any): boolean;
+    /** Verifica se l'elemento puo essere duplicato. */
+    canDuplicateItem(item: any): boolean;
+    /** Verifica se l'elemento puo essere visualizzato in readonly. */
+    canViewItem(item: any): boolean;
+    getEditTooltip(item: any): string;
+    getDeleteTooltip(item: any): string;
+    getDuplicateTooltip(item: any): string;
+    getViewTooltip(item: any): string;
+    getRowClasses(item: any, index: number): string;
+    shouldShowEllipsis(col: UiCrudTableColumn, value: any): boolean;
+    truncateText(col: UiCrudTableColumn, value: any): string;
+    getFullText(value: any): string;
+    /** Attiva la modalita inserimento. */
+    activateInsertMode(): void;
+    /** Attiva la modalita modifica per un elemento. */
+    activateEditMode(item: T, index: number): void;
+    /** Attiva la modalita visualizzazione readonly per un elemento. */
+    activateViewMode(item: T, index: number): void;
+    /** Attiva la modalita duplicazione per un elemento. */
+    activateDuplicateMode(item: T): void;
+    /** Annulla il form e torna alla vista tabella. */
+    cancelForm(): void;
+    /** Salva i dati del form (insert/edit/duplicate). */
+    saveForm(): void;
+    /** Elimina un elemento con conferma tramite UiModalService. */
+    deleteItem(item: T, index: number): void;
+    onRowClick(item: T): void;
+    /** @internal */
+    onViewBtnClick(event: Event, item: T, index: number): void;
+    /** @internal */
+    onEditBtnClick(event: Event, item: T, index: number): void;
+    /** @internal */
+    onDuplicateBtnClick(event: Event, item: T): void;
+    /** @internal */
+    onDeleteBtnClick(event: Event, item: T, index: number): void;
+    /** @internal Track function per il loop @for. */
+    trackByFn: (index: number, item: any) => any;
+    /** @internal Genera una chiave per la cache dei dati del form. */
+    private generateCacheKey;
+    /** @internal Invalida la cache dei dati del form. */
+    private invalidateFormCache;
+    /** @internal Configura i pulsanti in base alla modalita corrente. */
+    private setupButtons;
+    /** @internal Restituisce la label del pulsante salva in base alla modalita. */
+    private getSaveButtonLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiCrudTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiCrudTableComponent<any>, "ui-crud-table", never, { "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "config": { "alias": "config"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "initMapper": { "alias": "initMapper"; "required": false; }; }, { "dataChange": "dataChange"; "itemAdd": "itemAdd"; "itemEdit": "itemEdit"; "itemDelete": "itemDelete"; "itemDuplicate": "itemDuplicate"; "rowClick": "rowClick"; }, never, never, true, never>;
+}

package/lib/components/crud-table/crud-table.types.d.ts

@@ -0,0 +1,207 @@
+/**
+ * @module ng-ui-system/crud-table
+ * Tipi e interfacce per UiCrudTable.
+ */
+import { TemplateRef } from '@angular/core';
+import { UiIconName } from '../../core/types';
+import { UiFormSchema } from '../form-builder/types/schema.types';
+export { UiIconName };
+/**
+ * Modalita operative della CRUD table.
+ *
+ * | Modalita    | Descrizione                                  |
+ * |-------------|----------------------------------------------|
+ * | `view`      | Visualizzazione tabella (stato iniziale)      |
+ * | `insert`    | Inserimento nuovo elemento tramite form       |
+ * | `edit`      | Modifica elemento esistente                   |
+ * | `duplicate` | Duplicazione di un elemento                   |
+ * | `readonly`  | Visualizzazione dettaglio in sola lettura      |
+ */
+export type UiCrudMode = 'view' | 'insert' | 'edit' | 'duplicate' | 'readonly';
+/**
+ * Definizione di una colonna della CRUD table.
+ *
+ * @usageNotes
+ * ### Colonna testuale semplice
+ * ```typescript
+ * const col: UiCrudTableColumn = {
+ *   key: 'name',
+ *   header: 'Nome',
+ *   width: '200px',
+ * };
+ * ```
+ *
+ * ### Colonna con template personalizzato
+ * ```typescript
+ * const col: UiCrudTableColumn = {
+ *   key: 'status',
+ *   header: 'Stato',
+ *   template: myStatusTemplate,
+ * };
+ * ```
+ */
+export interface UiCrudTableColumn {
+    /** Chiave della proprieta nell'oggetto riga (usata per accedere al valore). */
+    key: string;
+    /** Testo dell'intestazione della colonna. */
+    header: string;
+    /**
+     * Template personalizzato per la cella.
+     * Il contesto fornisce: `$implicit` (riga), `column` (definizione), `index` (indice riga), `value` (valore cella).
+     */
+    template?: TemplateRef<any>;
+    /**
+     * Template personalizzato per l'intestazione.
+     * Il contesto fornisce: `$implicit` (colonna), `column` (definizione).
+     */
+    headerTemplate?: TemplateRef<any>;
+    /** Larghezza CSS della colonna (es. '120px', '20%'). */
+    width?: string;
+    /** Allineamento del testo nella colonna. @default 'left' */
+    align?: 'left' | 'center' | 'right';
+    /**
+     * Tronca il testo oltre maxLength caratteri con ellipsis e tooltip automatico.
+     * @default false
+     */
+    ellipsis?: boolean;
+    /**
+     * Numero massimo di caratteri prima del troncamento.
+     * Attivo solo quando `ellipsis` e `true`.
+     * @default 50
+     */
+    maxLength?: number;
+}
+/**
+ * Configurazione completa della CRUD table.
+ *
+ * Controlla lo schema del form, le label dei pulsanti, i permessi
+ * per azione (globali e per-riga) e i callback pre-apertura form.
+ *
+ * @usageNotes
+ * ### Configurazione base
+ * ```typescript
+ * const config: UiCrudTableConfig = {
+ *   formSchema: myFormSchema,
+ *   tableLabel: 'Utenti',
+ *   emptyMessage: 'Nessun utente presente',
+ * };
+ * ```
+ *
+ * ### Tabella con permessi granulari
+ * ```typescript
+ * const config: UiCrudTableConfig = {
+ *   formSchema: mySchema,
+ *   allowEdit: true,
+ *   allowDelete: true,
+ *   allowDuplicate: true,
+ *   canEdit: (item) => item.status !== 'locked',
+ *   canDelete: (item) => item.role !== 'admin',
+ * };
+ * ```
+ */
+export interface UiCrudTableConfig {
+    /** Schema per il form builder (inserimento/modifica). */
+    formSchema: UiFormSchema;
+    /** Etichetta della tabella (per accessibilita). */
+    tableLabel?: string;
+    /** Messaggio visualizzato quando non ci sono dati. @default 'Nessun elemento presente' */
+    emptyMessage?: string;
+    /** Label del pulsante "Aggiungi". @default 'Aggiungi' */
+    addButtonLabel?: string;
+    /** Label del pulsante "Salva" (insert). @default 'Salva' */
+    saveButtonLabel?: string;
+    /** Label del pulsante "Annulla". @default 'Annulla' */
+    cancelButtonLabel?: string;
+    /** Label del pulsante "Aggiorna" (edit). @default 'Aggiorna' */
+    updateButtonLabel?: string;
+    /** Label del pulsante "Duplica" (duplicate). @default 'Duplica' */
+    duplicateButtonLabel?: string;
+    /** Messaggio per il dialogo di conferma eliminazione. */
+    deleteConfirmMessage?: string;
+    /**
+     * Abilita il pulsante "Aggiungi" in modalita view.
+     * @default true
+     */
+    allowAdd?: boolean;
+    /**
+     * Abilita la modifica degli elementi.
+     * @default true
+     */
+    allowEdit?: boolean;
+    /**
+     * Abilita l'eliminazione degli elementi.
+     * @default true
+     */
+    allowDelete?: boolean;
+    /**
+     * Abilita la duplicazione degli elementi.
+     * @default false
+     */
+    allowDuplicate?: boolean;
+    /**
+     * Abilita la visualizzazione in sola lettura.
+     * @default false
+     */
+    allowView?: boolean;
+    /**
+     * Determina se una specifica riga puo essere modificata.
+     * Se non specificata, usa `allowEdit` globale.
+     */
+    canEdit?: (item: any, readonly: boolean) => boolean;
+    /**
+     * Determina se una specifica riga puo essere eliminata.
+     * Se non specificata, usa `allowDelete` globale.
+     */
+    canDelete?: (item: any, readonly: boolean) => boolean;
+    /**
+     * Determina se una specifica riga puo essere duplicata.
+     * Se non specificata, usa `allowDuplicate` globale.
+     */
+    canDuplicate?: (item: any, readonly: boolean) => boolean;
+    /**
+     * Determina se una specifica riga puo essere visualizzata in readonly.
+     * Se non specificata, usa `allowView` globale.
+     */
+    canView?: (item: any) => boolean;
+    /**
+     * Restituisce classi CSS aggiuntive per una specifica riga.
+     * Utile per evidenziare righe in base allo stato.
+     */
+    getRowClass?: (item: any, index: number) => string | string[];
+    /** Tooltip personalizzato per l'azione Edit. */
+    getEditTooltip?: (item: any) => string;
+    /** Tooltip personalizzato per l'azione Delete. */
+    getDeleteTooltip?: (item: any) => string;
+    /** Tooltip personalizzato per l'azione Duplicate. */
+    getDuplicateTooltip?: (item: any) => string;
+    /** Tooltip personalizzato per l'azione View. */
+    getViewTooltip?: (item: any) => string;
+    /** Proprieta usata come chiave di tracking per le righe. @default 'id' */
+    trackByProperty?: string;
+    /**
+     * Callback invocato prima dell'apertura del form.
+     * Permette al componente genitore di modificare lo schema
+     * (es. disabilitare opzioni gia utilizzate).
+     */
+    onBeforeFormOpen?: (mode: UiCrudMode, editingItem: any, allData: any[]) => void;
+}
+/**
+ * Evento emesso alla modifica di un elemento.
+ */
+export interface UiCrudEditEvent<T = any> {
+    /** Elemento modificato. */
+    item: T;
+    /** Indice dell'elemento nella lista. */
+    index: number;
+    /** Dati originali prima della modifica. */
+    originalData: any;
+}
+/**
+ * Evento emesso all'eliminazione di un elemento.
+ */
+export interface UiCrudDeleteEvent<T = any> {
+    /** Elemento eliminato. */
+    item: T;
+    /** Indice dell'elemento nella lista. */
+    index: number;
+}

package/lib/components/crud-table/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ng-ui-system — CRUD Table entry point.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UiCrudTableComponent,
+ *   UiCrudTableColumn,
+ *   UiCrudTableConfig,
+ *   UiCrudMode,
+ * } from 'ng-ui-system';
+ * ```
+ */
+export { UiCrudTableComponent } from './crud-table.component';
+export { UiCrudTableColumn, UiCrudTableConfig, UiCrudMode, UiCrudEditEvent, UiCrudDeleteEvent, } from './crud-table.types';

package/lib/components/form-builder/adapters/it-date-adapter.d.ts

@@ -0,0 +1,32 @@
+import { NativeDateAdapter, MatDateFormats } from '@angular/material/core';
+import * as i0 from "@angular/core";
+/**
+ * Adapter personalizzato per il parsing delle date in formato italiano DD/MM/YYYY.
+ *
+ * Estende il NativeDateAdapter di Angular Material per gestire:
+ * - Parsing: converte stringhe DD/MM/YYYY in oggetti Date
+ * - Formattazione: visualizza le date nel formato italiano
+ * - Primo giorno della settimana: Lunedi (1)
+ */
+export declare class UiItalianDateAdapter extends NativeDateAdapter {
+    /**
+     * Il primo giorno della settimana e Lunedi (1).
+     */
+    getFirstDayOfWeek(): number;
+    /**
+     * Parsing di una stringa di data in formato DD/MM/YYYY.
+     * Supporta sia il formato con separatore `/` che `-`.
+     */
+    parse(value: any): Date | null;
+    /**
+     * Formatta una data in formato DD/MM/YYYY per la visualizzazione.
+     */
+    format(date: Date, displayFormat: object): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiItalianDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiItalianDateAdapter>;
+}
+/**
+ * Formati data italiani per Angular Material.
+ * Configura il datepicker per usare DD/MM/YYYY.
+ */
+export declare const UI_IT_DATE_FORMATS: MatDateFormats;

package/lib/components/form-builder/directives/currency-input.directive.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, OnInit, Renderer2 } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Direttiva per formattazione input valuta.
+ *
+ * Formatta il valore numerico con separatori italiani (1.234,56)
+ * e simbolo valuta opzionale. In fase di focus l'utente modifica
+ * il valore raw, al blur viene riformattato.
+ *
+ * Implementa `ControlValueAccessor` per integrazione con Reactive Forms.
+ *
+ * @selector [uiCurrencyInput]
+ *
+ * @example
+ * ```html
+ * <input uiCurrencyInput currencySymbol="EUR" [decimalPlaces]="2" />
+ * ```
+ */
+export declare class UiCurrencyInputDirective implements ControlValueAccessor, OnInit {
+    private el;
+    private renderer;
+    /** Simbolo valuta visualizzato. @default 'EUR' */
+    currencySymbol: string;
+    /** Numero di decimali. @default 2 */
+    decimalPlaces: number;
+    private rawValue;
+    private onChange;
+    private onTouched;
+    private isFocused;
+    constructor(el: ElementRef<HTMLInputElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(value: string): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private parseInput;
+    /** Mostra il valore formattato con separatori italiani e simbolo. */
+    private displayFormatted;
+    /** Formattazione italiana: 1.234,56 */
+    private formatItalian;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiCurrencyInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiCurrencyInputDirective, "[uiCurrencyInput]", never, { "currencySymbol": { "alias": "currencySymbol"; "required": false; }; "decimalPlaces": { "alias": "decimalPlaces"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-builder/form-builder.component.d.ts

@@ -0,0 +1,183 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, AfterViewInit } from '@angular/core';
+import { FormGroup, FormControl, FormGroupDirective, NgForm } from '@angular/forms';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { UiButtonDescriptor } from '../../components/button/index';
+import { UiFormSchema, UiFormData, UiFormCustomEvent } from './types/schema.types';
+import { UiFormFieldDescriptor, UiFieldOption } from './types/field.types';
+import { UiFormValidationState, UiFormErrorDetail } from './types/validation.types';
+import * as i0 from "@angular/core";
+/**
+ * ErrorStateMatcher custom per il form builder.
+ * Mostra lo stato di errore quando il campo e invalido E (touched OPPURE dirty).
+ * Sostituisce il matcher di default di Angular Material.
+ */
+export declare class UiFormErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+/**
+ * Form builder data-driven e schema-based.
+ *
+ * Genera un form completo a partire da uno schema dichiarativo (`UiFormSchema`).
+ * Supporta 16 tipi di campo, validazione condizionale, cross-field validation,
+ * date con offset, opzioni dipendenti/dinamiche, sezioni collapsibili,
+ * error summary con scroll-to-field e button override.
+ *
+ * @selector ui-form-builder
+ *
+ * @example
+ * ```html
+ * <ui-form-builder
+ *   [schema]="formSchema"
+ *   [initialData]="userData"
+ *   (formSubmit)="onSubmit($event)"
+ *   (valueChange)="onChange($event)"
+ * />
+ * ```
+ */
+export declare class UiFormBuilderComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
+    private readonly cdr;
+    private readonly elRef;
+    private readonly conditionService;
+    private readonly validationService;
+    private readonly destroy$;
+    private valueChangeSub?;
+    /** ID schema corrente -- usato per evitare rebuild superflui. */
+    private currentSchemaId;
+    /** Schema del form. */
+    schema: UiFormSchema;
+    /** Dati iniziali per la prevalorizzazione. */
+    initialData: UiFormData;
+    /** Modalita sola lettura globale. */
+    readonly: boolean;
+    /** Stato disabilitato globale. */
+    disabled: boolean;
+    /** Override dei pulsanti di default. */
+    buttonsOverride?: UiButtonDescriptor[];
+    /** Chiave del pulsante in stato di caricamento. */
+    loadingFor: string | null;
+    valueChange: EventEmitter<UiFormData>;
+    validationChange: EventEmitter<UiFormValidationState>;
+    formSubmit: EventEmitter<UiFormData>;
+    formReset: EventEmitter<void>;
+    customEvent: EventEmitter<UiFormCustomEvent>;
+    formGroup: FormGroup;
+    /** Mappa campo -> opzioni filtrate (per autocomplete e dependent). */
+    filteredOptions: Record<string, UiFieldOption[]>;
+    /** Campi prevalorizzati (mostrano errori subito). */
+    prevalorizedFields: Set<string>;
+    /** Mappa campo -> regole di validazione (per lookup rapido). */
+    private validationRulesMap;
+    /** Mappa dipendenze: campoTarget -> campi dipendenti. */
+    private fieldDependencies;
+    /** Flag per evitare emissioni durante l'inizializzazione. */
+    private isInitializing;
+    get allFields(): UiFormFieldDescriptor[];
+    get formErrors(): UiFormErrorDetail[];
+    get formButtons(): UiButtonDescriptor[];
+    ngOnInit(): void;
+    /**
+     * Rileva cambiamenti sugli @Input.
+     * Ricostruisce il form quando cambia lo schema (id diverso).
+     * Cruciale per il wizard che cambia schema ad ogni step.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Inizializza il form dallo schema corrente.
+     * Estratto per poter essere richiamato sia da ngOnInit che da ngOnChanges.
+     */
+    private initFormFromSchema;
+    /**
+     * Pulisce lo stato del form prima di un rebuild.
+     */
+    private destroyForm;
+    private buildForm;
+    private applyAllValidators;
+    private evaluateAllConditions;
+    private buildDependencyMap;
+    private updateDependentOptions;
+    /** Verifica se un campo e visibile. */
+    isFieldVisible(fieldKey: string): boolean;
+    /** Verifica se un campo e obbligatorio (include validazione condizionale). */
+    isFieldRequired(fieldKey: string): boolean;
+    /** Verifica se una sezione e visibile. */
+    isSectionVisible(sectionId: string): boolean;
+    /** Verifica se mostrare errori per un campo. */
+    shouldShowFieldErrors(fieldKey: string): boolean;
+    /** Errori di un campo come array di messaggi. */
+    getFieldErrors(fieldKey: string): string[];
+    /** Valore completo del form (include campi disabilitati). */
+    getFormValue(): UiFormData;
+    /** Il form e valido. */
+    isFormValid(): boolean;
+    /** Stato di validazione completo. */
+    getValidationState(): UiFormValidationState;
+    /** Errori dettagliati per l'error summary. */
+    getDetailedFormErrors(): UiFormErrorDetail[];
+    /** Conta errori totali. */
+    getFormErrorsCount(): number;
+    /** Controlla se ci sono errori. */
+    hasFormErrors(): boolean;
+    /** Controllo per un campo. */
+    getFieldControl(key: string): FormControl | null;
+    /** Aggiorna il valore di un campo programmaticamente. */
+    updateFieldValue(key: string, value: any): void;
+    /** Forza la validazione di tutti i campi. */
+    validateAllFields(): void;
+    /** Scrolla al campo e lo evidenzia. */
+    scrollToField(fieldKey: string): void;
+    /** Submit del form. */
+    onSubmit(): void;
+    /** Reset del form. */
+    onReset(): void;
+    /** Opzioni per un campo (filtrando per autocomplete query). */
+    getFieldOptions(field: UiFormFieldDescriptor): UiFieldOption[];
+    /** Filtra opzioni per autocomplete. */
+    filterOptions(field: UiFormFieldDescriptor, query: string): void;
+    /** Display fn per autocomplete. */
+    displayFn(options: UiFieldOption[]): (value: any) => string;
+    /** Seleziona tutte le opzioni per multiselect. */
+    selectAll(field: UiFormFieldDescriptor): void;
+    /** Aggiunge un chip al freemultiselect (da token: Enter o virgola). */
+    addFreeChip(field: UiFormFieldDescriptor, event: any): void;
+    /** Aggiunge un chip al freemultiselect sull'evento blur dell'input. */
+    addFreeChipOnBlur(field: UiFormFieldDescriptor, event: FocusEvent): void;
+    /** Rimuove un chip dal freemultiselect. */
+    removeFreeChip(field: UiFormFieldDescriptor, chipValue: string): void;
+    /** Verifica se un chip e protetto dalla cancellazione. */
+    isChipProtected(field: UiFormFieldDescriptor, chipValue: string): boolean;
+    /** Rimuove chip da multiselect. */
+    removeMultiselectChip(field: UiFormFieldDescriptor, chipValue: any): void;
+    /** Trova label di un'opzione dal valore. */
+    getOptionLabel(field: UiFormFieldDescriptor, value: any): string;
+    /** Tipo di input nativo per il campo. */
+    getNativeInputType(field: UiFormFieldDescriptor): string;
+    /**
+     * Genera le classi CSS per il wrapper di un campo,
+     * combinando eventuali cssClasses dallo schema con le classi
+     * responsive per il sistema a griglia base-12.
+     *
+     * Mobile-first: tutti i campi sono span-12 di default (100%).
+     * Le classi `ui-col-{breakpoint}-{n}` attivano la larghezza
+     * configurata solo dal breakpoint indicato in su.
+     *
+     * Breakpoint supportati: sm (≥576px), md (≥768px), lg (≥1024px), xl (≥1280px).
+     */
+    getFieldWrapperClasses(field: UiFormFieldDescriptor): string;
+    /** Character count per textarea/text con maxLength. */
+    getCharCount(fieldKey: string): {
+        current: number;
+        max: number;
+    } | null;
+    private isObservable;
+    /**
+     * Normalizza la chiave del tipo di validazione dallo schema (camelCase)
+     * alla chiave di errore usata da Angular (lowercase).
+     * Es: "minLength" -> "minlength", "maxLength" -> "maxlength".
+     */
+    private normalizeValidationKey;
+    private getDefaultErrorMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFormBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiFormBuilderComponent, "ui-form-builder", never, { "schema": { "alias": "schema"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "buttonsOverride": { "alias": "buttonsOverride"; "required": false; }; "loadingFor": { "alias": "loadingFor"; "required": false; }; }, { "valueChange": "valueChange"; "validationChange": "validationChange"; "formSubmit": "formSubmit"; "formReset": "formReset"; "customEvent": "customEvent"; }, never, never, true, never>;
+}