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

package/lib/components/modal/modal.service.d.ts

@@ -0,0 +1,93 @@
+import { Type } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Observable } from 'rxjs';
+import { UiConfirmDialogData, UiModalOpenConfig } from './modal.types';
+import * as i0 from "@angular/core";
+/**
+ * Servizio per aprire modali e dialoghi di conferma.
+ *
+ * Gestisce lo stacking intelligente: una modale regolare puo
+ * ospitare al massimo un dialogo di conferma sopra di se.
+ * Non e possibile stackare due modali regolari.
+ *
+ * @usageNotes
+ *
+ * ### Aprire una modale personalizzata
+ * ```typescript
+ * const ref = this.modalService.open(MyDialogComponent, {
+ *   size: 'lg',
+ *   data: { userId: 123 },
+ * });
+ *
+ * ref.afterClosed().subscribe(result => {
+ *   console.log('Risultato:', result);
+ * });
+ * ```
+ *
+ * ### Conferma rapida
+ * ```typescript
+ * this.modalService.confirm('Confermi questa azione?')
+ *   .subscribe(ok => { if (ok) this.procedi(); });
+ * ```
+ *
+ * ### Preset di conferma
+ * ```typescript
+ * this.modalService.confirmDelete('Progetto Alpha')
+ *   .subscribe(ok => { if (ok) this.elimina(); });
+ * ```
+ */
+export declare class UiModalService {
+    /** @internal Istanza MatDialog per la gestione overlay. */
+    private readonly dialog;
+    /** @internal Stack delle modali regolari aperte. */
+    private _modalStack;
+    /** @internal Traccia se un dialogo di conferma e attualmente aperto. */
+    private _confirmOpen;
+    /**
+     * Apre una modale con un componente personalizzato.
+     *
+     * Il componente aperto puo iniettare `MAT_DIALOG_DATA` per accedere
+     * ai dati e `MatDialogRef` per chiudere la modale.
+     *
+     * @param component - Componente standalone da renderizzare nella modale
+     * @param config - Configurazione (dimensione, dati, comportamento)
+     * @returns Riferimento alla modale aperta
+     */
+    open<T, D = unknown, R = unknown>(component: Type<T>, config?: UiModalOpenConfig<D>): MatDialogRef<T, R>;
+    /**
+     * Apre un dialogo di conferma.
+     *
+     * Accetta una stringa semplice (messaggio) o un oggetto di
+     * configurazione completo. Puo essere aperto sopra una modale
+     * esistente (stacking consentito).
+     *
+     * @param messageOrConfig - Messaggio o configurazione completa
+     * @returns Observable che emette `true` se confermato, `false` se annullato
+     */
+    confirm(messageOrConfig: string | UiConfirmDialogData): Observable<boolean>;
+    /**
+     * Scorciatoia: conferma eliminazione.
+     * Variante `delete` con icona cestino e pulsante warn.
+     *
+     * @param itemName - Nome opzionale dell'elemento da eliminare
+     */
+    confirmDelete(itemName?: string): Observable<boolean>;
+    /**
+     * Scorciatoia: conferma abbandono modifiche.
+     * Variante `warn` con icona avviso.
+     */
+    confirmDiscard(): Observable<boolean>;
+    /**
+     * Scorciatoia: conferma salvataggio.
+     * Variante `confirm` con icona check.
+     */
+    confirmSave(): Observable<boolean>;
+    /** Chiude tutte le modali e dialoghi aperti. */
+    closeAll(): void;
+    /** Indica se ci sono modali o dialoghi attualmente aperti. */
+    get hasOpenDialogs(): boolean;
+    /** Numero di modali regolari attualmente aperte. */
+    get openModalCount(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiModalService>;
+}

package/lib/components/modal/modal.types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * @module ng-ui-system/modal
+ * Tipi e interfacce per UiModal, UiConfirmDialog e UiModalService.
+ */
+import { UiVariant, UiIconName } from '../../core/types';
+export { UiVariant, UiIconName };
+/**
+ * Dimensioni predefinite della modale.
+ *
+ * | Valore        | Larghezza | Caso d'uso                        |
+ * |--------------|-----------|-----------------------------------|
+ * | `sm`         | 400px     | Confirm, messaggi brevi           |
+ * | `md`         | 560px     | Form semplici, dettagli           |
+ * | `lg`         | 720px     | Form complessi, tabelle interne   |
+ * | `xl`         | 900px     | Dashboard modali, preview         |
+ * | `fullscreen` | 95vw      | Operazioni a schermo intero       |
+ */
+export type UiModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
+/**
+ * Configurazione strutturale della modale.
+ * Passata come `@Input()` al componente `UiModalComponent`.
+ *
+ * @usageNotes
+ * ### Utilizzo base
+ * ```typescript
+ * const config: UiModalConfig = {
+ *   title: 'Modifica utente',
+ *   size: 'md',
+ * };
+ * ```
+ */
+export interface UiModalConfig {
+    /** Titolo visualizzato nell'header della modale. */
+    title?: string;
+    /** Dimensione della modale. @default 'md' */
+    size?: UiModalSize;
+    /** Mostra il pulsante di chiusura nell'header. @default true */
+    showCloseButton?: boolean;
+    /** Impedisce la chiusura tramite backdrop click o tasto Escape. @default false */
+    disableClose?: boolean;
+    /** Nasconde l'area footer della modale. @default false */
+    hideFooter?: boolean;
+}
+/**
+ * Configurazione per aprire una modale tramite `UiModalService.open()`.
+ *
+ * @usageNotes
+ * ```typescript
+ * this.modalService.open(MyComponent, {
+ *   size: 'lg',
+ *   data: { userId: 123 },
+ *   disableClose: true,
+ * });
+ * ```
+ */
+export interface UiModalOpenConfig<D = unknown> {
+    /** Dimensione della modale. @default 'md' */
+    size?: UiModalSize;
+    /** Dati da iniettare nel componente aperto tramite MAT_DIALOG_DATA. */
+    data?: D;
+    /** Impedisce la chiusura tramite backdrop click o tasto Escape. @default false */
+    disableClose?: boolean;
+    /** Classe CSS aggiuntiva per il pannello overlay. */
+    panelClass?: string;
+}
+/**
+ * Varianti semantiche del dialogo di conferma.
+ *
+ * | Variante   | Icona default      | Colore pulsante | Caso d'uso                |
+ * |-----------|-------------------|----------------|---------------------------|
+ * | `confirm` | `check-circle`     | `primary`       | Conferma azione positiva   |
+ * | `delete`  | `trash-2`          | `warn`          | Eliminazione irreversibile |
+ * | `warn`    | `alert-triangle`   | `warn`          | Avviso con conferma        |
+ * | `info`    | `info`             | `primary`       | Informazione con azione    |
+ */
+export type UiConfirmVariant = 'confirm' | 'delete' | 'warn' | 'info';
+/**
+ * Configurazione per il dialogo di conferma.
+ * Passata a `UiModalService.confirm()`.
+ *
+ * @usageNotes
+ * ### Conferma semplice (solo stringa)
+ * ```typescript
+ * this.modalService.confirm('Sei sicuro di voler procedere?');
+ * ```
+ *
+ * ### Conferma configurata
+ * ```typescript
+ * this.modalService.confirm({
+ *   title: 'Elimina elemento',
+ *   message: 'Questa azione non puo essere annullata.',
+ *   variant: 'delete',
+ *   confirmText: 'Elimina',
+ * });
+ * ```
+ */
+export interface UiConfirmDialogData {
+    /** Titolo del dialogo. */
+    title?: string;
+    /** Messaggio principale del dialogo. */
+    message: string;
+    /** Testo del pulsante di conferma. @default 'Conferma' */
+    confirmText?: string;
+    /** Testo del pulsante di annullamento. @default 'Annulla' */
+    cancelText?: string;
+    /** Variante semantica che determina icona e colore. @default 'confirm' */
+    variant?: UiConfirmVariant;
+    /** Icona personalizzata (sovrascrive quella della variante). */
+    icon?: UiIconName;
+}

package/lib/components/page-header/breadcrumb.service.d.ts

@@ -0,0 +1,96 @@
+import { ActivatedRoute } from '@angular/router';
+import { UiBreadcrumbItem } from './page-header.types';
+import * as i0 from "@angular/core";
+/**
+ * Service that builds a nested breadcrumb trail from Angular route configuration.
+ *
+ * Routes must define `data.id`, `data.title`, and optionally `data.breadcrumbs`
+ * (an array of parent route IDs) for the chain to resolve correctly.
+ *
+ * Supports lazy-loaded routes: the internal route map is rebuilt automatically
+ * whenever new routes are loaded via `NavigationEnd`.
+ *
+ * Label resolution for route parameters (`:param`) is delegated to an injectable
+ * `UiLabelResolverFn` via the `UI_BREADCRUMB_LABEL_RESOLVER` token.
+ *
+ * @usageNotes
+ * ### Route configuration
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'users',
+ *     data: { id: 'users', title: 'Utenti' },
+ *     children: [
+ *       {
+ *         path: ':userId',
+ *         data: { id: 'user-detail', title: ':userId', breadcrumbs: ['users'] },
+ *         component: UserDetailComponent,
+ *       },
+ *     ],
+ *   },
+ * ];
+ * ```
+ *
+ * ### Custom label resolver
+ * ```typescript
+ * providers: [
+ *   {
+ *     provide: UI_BREADCRUMB_LABEL_RESOLVER,
+ *     useValue: (name: string, value: string) =>
+ *       name === 'userId' ? `User #${value}` : value,
+ *   },
+ * ]
+ * ```
+ */
+export declare class UiBreadcrumbService {
+    private readonly router;
+    private readonly labelResolver;
+    /** @internal Map of route ID → breadcrumb configuration. */
+    private breadcrumbMap;
+    /** @internal Tracks route count to detect lazy-loaded route additions. */
+    private lastRouteConfigLength;
+    /** @internal Last computed breadcrumbs for navigateBack. */
+    private lastBreadcrumbs;
+    constructor();
+    /**
+     * Computes the breadcrumb trail for the currently active route.
+     *
+     * @param route - The root `ActivatedRoute` (typically injected in the component).
+     * @returns Ordered array of breadcrumb items from root to current route.
+     */
+    getBreadcrumbsForRoute(route: ActivatedRoute): UiBreadcrumbItem[];
+    /**
+     * Navigates to the previous breadcrumb (parent route).
+     * Falls back to `fallbackUrl` (default: `/`) when no parent exists.
+     */
+    navigateBack(fallbackUrl?: string): void;
+    /** @internal Collects all route params from the full path (including parents). */
+    private collectParamsFromPath;
+    /** @internal Rebuilds the map only when new lazy routes appear. */
+    private rebuildRouteMapIfNeeded;
+    /** @internal Recursively counts routes including lazy-loaded children. */
+    private countRoutes;
+    /** @internal Clears and rebuilds the full route → breadcrumb map. */
+    private rebuildRouteMap;
+    /** @internal Recursively walks route tree to build the breadcrumb map. */
+    private buildRouteMap;
+    /** @internal Builds the full breadcrumb chain for a route by its ID. */
+    private buildBreadcrumbChain;
+    /** @internal Resolves parent breadcrumbs from ordered parent IDs. */
+    private getParentChain;
+    /**
+     * @internal Resolves `:param` placeholders in a label using
+     * the injected label resolver function.
+     */
+    private resolveLabel;
+    /** @internal Resolves `:param` placeholders in a path and creates a URL. */
+    private resolveUrl;
+    /** @internal Normalizes path by collapsing double slashes and trimming trailing slash. */
+    private normalizePath;
+    /** @internal Removes query parameters from a URL. */
+    private stripQueryParams;
+    /** @internal Caches the fully resolved URL for a route ID. */
+    private saveFullPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiBreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiBreadcrumbService>;
+}

package/lib/components/page-header/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ng-ui-system — Page Header entry point.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   UiPageHeaderComponent,
+ *   UiBreadcrumbService,
+ *   UiBreadcrumbItem,
+ *   UI_BREADCRUMB_LABEL_RESOLVER,
+ * } from 'ng-ui-system';
+ * ```
+ */
+export { UiPageHeaderComponent } from './page-header.component';
+export { UiBreadcrumbService } from './breadcrumb.service';
+export { UiBreadcrumbItem, UiBreadcrumbConfig, UiLabelResolverFn, UI_BREADCRUMB_LABEL_RESOLVER, } from './page-header.types';

package/lib/components/page-header/page-header.component.d.ts

@@ -0,0 +1,59 @@
+import { OnInit } from '@angular/core';
+import { UiBreadcrumbItem } from './page-header.types';
+import * as i0 from "@angular/core";
+/**
+ * Page header component that renders a breadcrumb navigation trail
+ * and a page title. Integrates with `UiBreadcrumbService` to
+ * automatically derive breadcrumbs from Angular route configuration.
+ *
+ * The breadcrumb trail is generated from route `data` properties:
+ * - `data.id` — unique route identifier
+ * - `data.title` — display label
+ * - `data.breadcrumbs` — ordered array of parent route IDs
+ *
+ * @selector ui-page-header
+ *
+ * @example
+ * ```html
+ * <!-- Auto breadcrumbs from route data -->
+ * <ui-page-header />
+ *
+ * <!-- With explicit title override -->
+ * <ui-page-header title="Custom Title" />
+ *
+ * <!-- With document title update -->
+ * <ui-page-header [updateDocumentTitle]="true" titleSuffix=" | My App" />
+ * ```
+ */
+export declare class UiPageHeaderComponent implements OnInit {
+    /** Override the auto-detected page title. When empty, title is derived from the last breadcrumb. */
+    title: string;
+    /** Route path for the Home breadcrumb link. */
+    homeRoute: string;
+    /** Whether to display the Home link at the start of the trail. */
+    showHome: boolean;
+    /** When `true`, updates `document.title` on each navigation. */
+    updateDocumentTitle: boolean;
+    /** Suffix appended to `document.title` (e.g. `' | My App'`). Only used when `updateDocumentTitle` is `true`. */
+    titleSuffix: string;
+    /** @internal */
+    breadcrumbs: UiBreadcrumbItem[];
+    private readonly router;
+    private readonly activatedRoute;
+    private readonly titleService;
+    private readonly breadcrumbService;
+    private readonly destroyRef;
+    private readonly cdr;
+    /** Resolved page title: explicit `title` input wins, otherwise last breadcrumb label. */
+    get displayTitle(): string;
+    ngOnInit(): void;
+    /**
+     * Navigates to the previous breadcrumb (parent route).
+     * @param fallbackUrl - URL to navigate to when no parent exists (default: homeRoute).
+     */
+    navigateBack(fallbackUrl?: string): void;
+    /** @internal */
+    private refresh;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiPageHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiPageHeaderComponent, "ui-page-header", never, { "title": { "alias": "title"; "required": false; }; "homeRoute": { "alias": "homeRoute"; "required": false; }; "showHome": { "alias": "showHome"; "required": false; }; "updateDocumentTitle": { "alias": "updateDocumentTitle"; "required": false; }; "titleSuffix": { "alias": "titleSuffix"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/page-header/page-header.types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @module ng-ui-system/page-header
+ * Types and interfaces for UiPageHeader and UiBreadcrumbService.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Single breadcrumb item rendered in the navigation trail.
+ *
+ * @usageNotes
+ * ### Structure
+ * ```typescript
+ * const item: UiBreadcrumbItem = {
+ *   label: 'Dashboard',
+ *   url: '/dashboard',
+ *   isLast: false,
+ * };
+ * ```
+ */
+export interface UiBreadcrumbItem {
+    /** Display text for the breadcrumb link. */
+    label: string;
+    /** Navigation URL (Angular Router path). */
+    url: string;
+    /** Whether this is the last (current) breadcrumb in the trail. */
+    isLast: boolean;
+}
+/**
+ * Internal route configuration stored by UiBreadcrumbService.
+ * Built from Angular route `data` properties.
+ *
+ * @usageNotes
+ * ### Route data convention
+ * ```typescript
+ * {
+ *   path: 'users/:userId',
+ *   data: {
+ *     id: 'user-detail',
+ *     title: 'Dettaglio utente',
+ *     breadcrumbs: ['users-list'],
+ *   },
+ *   component: UserDetailComponent,
+ * }
+ * ```
+ */
+export interface UiBreadcrumbConfig {
+    /** Unique route identifier (from `route.data.id`). */
+    id: string;
+    /** Resolved route path pattern (may contain `:param` placeholders). */
+    path: string;
+    /** Display label (from `route.data.title` or fallback). */
+    label: string;
+    /** Ordered array of parent route IDs for building the breadcrumb chain. */
+    parentIds: string[];
+    /** Fully resolved URL captured at navigation time. */
+    fullPath?: string;
+    /** Raw route data metadata. */
+    metadata?: Record<string, any>;
+}
+/**
+ * Function signature for resolving route parameter values to human-readable labels.
+ *
+ * Consumers can provide a custom implementation via `UI_BREADCRUMB_LABEL_RESOLVER`
+ * to translate cryptic parameter values (e.g. UUIDs, slugs) into user-friendly text.
+ *
+ * @param paramName - The route parameter name (e.g. `'userId'`).
+ * @param paramValue - The raw parameter value from the URL (e.g. `'abc-123'`).
+ * @returns A human-readable label, or the original value if no mapping exists.
+ *
+ * @usageNotes
+ * ### Custom resolver
+ * ```typescript
+ * const myResolver: UiLabelResolverFn = (name, value) => {
+ *   if (name === 'status') {
+ *     return { pending: 'In attesa', active: 'Attivo' }[value] ?? value;
+ *   }
+ *   return value;
+ * };
+ *
+ * providers: [
+ *   { provide: UI_BREADCRUMB_LABEL_RESOLVER, useValue: myResolver },
+ * ]
+ * ```
+ */
+export type UiLabelResolverFn = (paramName: string, paramValue: string) => string;
+/**
+ * Injection token for providing a custom label resolver to UiBreadcrumbService.
+ *
+ * When not provided, parameters are displayed as-is (identity function).
+ *
+ * @example
+ * ```typescript
+ * // In your app.config.ts or module providers:
+ * { provide: UI_BREADCRUMB_LABEL_RESOLVER, useValue: myLabelResolver }
+ * ```
+ */
+export declare const UI_BREADCRUMB_LABEL_RESOLVER: InjectionToken<UiLabelResolverFn>;

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

@@ -0,0 +1,2 @@
+export { UiPaginatedTableComponent } from './paginated-table.component';
+export { UiTableColumn, UiTableSortEvent, UiTablePageEvent, } from './table.types';

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

@@ -0,0 +1,85 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { PageEvent } from '@angular/material/paginator';
+import { UiTableColumn, UiTableSortEvent, UiTablePageEvent } from './table.types';
+import * as i0 from "@angular/core";
+/**
+ * Tabella paginata standalone con ordinamento, colonne sticky,
+ * ellipsis automatica, stato di caricamento e template personalizzabili.
+ *
+ * Progettata per paginazione server-side: emette eventi di cambio pagina
+ * e ordinamento che il componente genitore gestisce per il recupero dati.
+ *
+ * @selector ui-paginated-table
+ *
+ * @example
+ * ```html
+ * <ui-paginated-table
+ *   [data]="users"
+ *   [columns]="columns"
+ *   [totalItems]="totalUsers"
+ *   [pageSize]="10"
+ *   [loading]="isLoading"
+ *   (pageChange)="onPageChange($event)"
+ *   (sortChange)="onSort($event)"
+ *   (rowClick)="onUserClick($event)"
+ * />
+ * ```
+ */
+export declare class UiPaginatedTableComponent {
+    /** @internal Identificatore univoco per l'istanza. */
+    readonly tableId: string;
+    /** Array di righe da visualizzare nella pagina corrente. */
+    data: Record<string, any>[];
+    /** Definizione delle colonne della tabella. */
+    columns: UiTableColumn[];
+    /** Numero totale di elementi (per la paginazione server-side). */
+    totalItems: number;
+    /** Numero di righe per pagina. */
+    pageSize: number;
+    /** Opzioni selezionabili per il numero di righe per pagina. */
+    pageSizeOptions: number[];
+    /** Indice della pagina corrente (0-based). */
+    pageIndex: number;
+    /** Mostra il paginatore sotto la tabella. */
+    showPaginator: boolean;
+    /** Mostra l'overlay di caricamento sopra la tabella. */
+    loading: boolean;
+    /** Messaggio visualizzato quando non ci sono dati. */
+    emptyMessage: string;
+    /** Template personalizzato per lo stato vuoto. */
+    emptyTemplate: TemplateRef<unknown> | null;
+    /** Emesso quando l'utente cambia pagina o numero di righe. */
+    pageChange: EventEmitter<UiTablePageEvent>;
+    /** Emesso quando l'utente ordina una colonna. */
+    sortChange: EventEmitter<UiTableSortEvent>;
+    /** Emesso quando l'utente clicca su una riga. */
+    rowClick: EventEmitter<Record<string, any>>;
+    /** @internal Colonna attualmente ordinata. */
+    currentSortColumn: string | null;
+    /** @internal Direzione ordinamento corrente. */
+    currentSortDirection: 'asc' | 'desc' | null;
+    /** @internal Gestisce il click su un'intestazione di colonna. */
+    onHeaderClick(col: UiTableColumn): void;
+    /** @internal Indica se la colonna e attualmente ordinata. */
+    isColumnSorted(col: UiTableColumn): boolean;
+    /** @internal Attributo aria-sort per accessibilita. */
+    getAriaSort(col: UiTableColumn): string | null;
+    /** @internal Gestisce il cambio pagina dal MatPaginator. */
+    onPageChange(event: PageEvent): void;
+    /** @internal Gestisce il click su una riga. */
+    onRowClick(row: Record<string, any>): void;
+    /** @internal Track function per il loop @for sulle righe. */
+    trackRow(index: number, row: Record<string, any>): unknown;
+    /** @internal Verifica se il testo deve essere troncato. */
+    shouldTruncate(value: unknown, col: UiTableColumn): boolean;
+    /** @internal Tronca il testo con ellipsis. */
+    truncateText(value: unknown, col: UiTableColumn): string;
+    /** @internal Classi CSS per l'header di colonna. */
+    getHeaderClasses(col: UiTableColumn): string;
+    /** @internal Classi CSS per una cella. */
+    getCellClasses(col: UiTableColumn): string;
+    /** @internal Calcola la prossima direzione nel ciclo asc -> desc -> null. */
+    private nextSortDirection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiPaginatedTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiPaginatedTableComponent, "ui-paginated-table", never, { "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "showPaginator": { "alias": "showPaginator"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "emptyTemplate": { "alias": "emptyTemplate"; "required": false; }; }, { "pageChange": "pageChange"; "sortChange": "sortChange"; "rowClick": "rowClick"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,81 @@
+/**
+ * @module ng-ui-system/table
+ * Tipi e interfacce per UiPaginatedTable.
+ */
+import { TemplateRef } from '@angular/core';
+/**
+ * Definizione di una colonna della tabella.
+ *
+ * @usageNotes
+ * ### Colonna testuale semplice
+ * ```typescript
+ * const col: UiTableColumn = {
+ *   property: 'name',
+ *   header: 'Nome',
+ *   sortable: true,
+ * };
+ * ```
+ *
+ * ### Colonna con template personalizzato
+ * ```typescript
+ * const col: UiTableColumn = {
+ *   property: 'status',
+ *   header: 'Stato',
+ *   template: statusTemplate,
+ * };
+ * ```
+ */
+export interface UiTableColumn {
+    /** Chiave della proprieta nell'oggetto riga. */
+    property: string;
+    /** Testo dell'intestazione della colonna. */
+    header: string;
+    /**
+     * Template personalizzato per la cella.
+     * Il contesto fornisce `$implicit` (riga) e `column` (definizione colonna).
+     *
+     * @example
+     * ```html
+     * <ng-template #statusTpl let-row>
+     *   <span [class]="'badge--' + row.status">{{ row.status }}</span>
+     * </ng-template>
+     * ```
+     */
+    template?: TemplateRef<unknown>;
+    /** Rende la colonna ordinabile con click sull'header. @default false */
+    sortable?: boolean;
+    /** Tipo di ordinamento per la logica client-side. @default 'text' */
+    sortType?: 'text' | 'number' | 'date';
+    /** Fissa la colonna a destra durante lo scroll orizzontale. @default false */
+    sticky?: boolean;
+    /** Tronca il testo oltre maxLength caratteri con ellipsis e tooltip. @default false */
+    ellipsis?: boolean;
+    /** Lunghezza massima del testo prima dell'ellipsis. @default 50 */
+    maxLength?: number;
+    /** Larghezza CSS personalizzata della colonna (es. '120px', '20%'). */
+    width?: string;
+    /** Allineamento del testo nella colonna. @default 'left' */
+    align?: 'left' | 'center' | 'right';
+}
+/**
+ * Evento di ordinamento emesso quando l'utente clicca su un'intestazione ordinabile.
+ */
+export interface UiTableSortEvent {
+    /** Proprieta della colonna ordinata. */
+    column: string;
+    /** Direzione dell'ordinamento. `null` indica ordinamento rimosso. */
+    direction: 'asc' | 'desc' | null;
+    /** Tipo di ordinamento della colonna. */
+    sortType: 'text' | 'number' | 'date';
+}
+/**
+ * Evento di cambio pagina emesso dal paginatore.
+ */
+export interface UiTablePageEvent {
+    /** Indice della pagina corrente (0-based). */
+    pageIndex: number;
+    /** Numero di righe per pagina. */
+    pageSize: number;
+    /** Numero totale di elementi. */
+    length: number;
+}