@wemake4u/form-controls 2.0.0 → 2.0.1

package/types/wemake4u-form-controls.d.ts

@@ -1,9 +1,10 @@
 import * as i0 from "@angular/core";
-import { AfterContentInit, ComponentRef, DoCheck, InjectionToken, Injector, OnDestroy, Provider, Signal, TemplateRef, Type } from "@angular/core";
-import { AbstractControl, ControlValueAccessor, ValidationErrors, Validator } from "@angular/forms";
+import { AfterContentInit, ComponentRef, DoCheck, EnvironmentProviders, InjectionToken, Injector, OnDestroy, Provider, Signal, TemplateRef, Type } from "@angular/core";
+import { AbstractControl, ControlValueAccessor, FormArray, FormGroup, ValidationErrors, Validator } from "@angular/forms";
 import { Options, Splide } from "@splidejs/splide";
-import { Params, QueryParamsHandling } from "@angular/router";
 import { Observable } from "rxjs";
+import { Row } from "@tanstack/angular-table";
+import { Params, QueryParamsHandling } from "@angular/router";
 /** Placements of the kit tooltip (`data-sirio-placement`), default `top`. */
 export type SirioTooltipPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
 /**
@@ -205,6 +206,20 @@ export declare const SIRIO_VALIDATION_DISPLAY: InjectionToken<SirioValidationDis
  * Usage: `providers: [provideSirioValidationDisplay('touched')]`
  */
 export declare function provideSirioValidationDisplay(display: SirioValidationDisplay): Provider;
+/**
+ * Look of a read-only data entry field:
+ * - `filled`: Sirio kit style, grey background and border (`.sirio-form-control[readonly]`, the same look as disabled);
+ * - `outline`: white background with the kit light border, so a read-only field (focusable, its text can be selected
+ *   and copied) is told apart from a disabled one. Disabled fields keep the kit grey fill in both cases.
+ */
+export type SirioReadonlyAppearance = 'filled' | 'outline';
+/** Default `readonlyAppearance` of every Sirio data entry control. */
+export declare const SIRIO_READONLY_APPEARANCE: InjectionToken<SirioReadonlyAppearance>;
+/**
+ * Sets the default `readonlyAppearance` of the Sirio controls (each control can override it).
+ * Usage: `providers: [provideSirioReadonlyAppearance('outline')]` (application or component providers).
+ */
+export declare function provideSirioReadonlyAppearance(appearance: SirioReadonlyAppearance): Provider;
 /**
  * How an invalid control is presented:
  * - `invalid`: error state (kit `sirio-is-invalid`) with `message` (or the resolved error message);
@@ -290,6 +305,12 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
   readonly inputId: import("@angular/core").InputSignal<string>;
   readonly name: import("@angular/core").InputSignal<string | null>;
   readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Look of the field when `readonly`: `filled` (kit grey fill, as disabled) or `outline` (white background with the
+   * kit light border). null = application default (`provideSirioReadonlyAppearance()`, `filled` otherwise).
+   * Disabled fields always keep the kit grey fill.
+   */
+  readonly readonlyAppearance: import("@angular/core").InputSignal<SirioReadonlyAppearance | null>;
   /** Visual "required" marker. It is also inferred from Validators.required on the bound control. */
   readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Disabled state when the component is used without Angular forms. */
@@ -375,6 +396,12 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
   readonly pendingVisible: import("@angular/core").WritableSignal<boolean>;
   private readonly defaultValidationDisplay;
   private readonly defaultValueSync;
+  private readonly defaultReadonlyAppearance;
+  /**
+   * `readonlyAppearance` or the application default. With `outline` the host gets the class
+   * `wm-sirio-readonly-outline`, used by the control styles (core/_sirio-readonly.scss).
+   */
+  readonly resolvedReadonlyAppearance: import("@angular/core").Signal<SirioReadonlyAppearance>;
   /** The validation state can be shown, according to `validationDisplay`. */
   readonly stateShown: import("@angular/core").Signal<boolean>;
   private readonly presenter;
@@ -482,6 +509,11 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
       "required": false;
       "isSignal": true;
     };
+    "readonlyAppearance": {
+      "alias": "readonlyAppearance";
+      "required": false;
+      "isSignal": true;
+    };
     "required": {
       "alias": "required";
       "required": false;
@@ -1466,7 +1498,8 @@ export declare const SIRIO_CAROUSEL_I18N: Record<string, string>;
 /**
  * Carousel of the Sirio web kit ("Carousel"), based on Splide as the kit (same version, the kit
  * `splide.min.css` and the `.sirio-carousel` styles): `div.splide.sirio-carousel.splide-N` >
- * `.splide__track` > `ul.splide__list` > `li.splide__slide`, initialised with the options of the
+ * `.splide__track` > `.splide__list` > `.splide__slide` (div elements: the slide roles set by Splide
+ * are not allowed on list items), initialised with the options of the
  * kit script (breakpoints for 1, 2 or 3 cards, kit arrow buttons, Italian labels).
  *
  * ```html
@@ -1539,13 +1572,22 @@ export declare class SirioCarousel {
 }
 /** Carousel components, for `imports: [SIRIO_CAROUSEL]`. */
 export declare const SIRIO_CAROUSEL: readonly [typeof SirioCarousel, typeof SirioCarouselSlide];
-/** An item of the breadcrumb. The last item is the current page (never a link). */
+/**
+ * An item of the breadcrumb. The last item is the current page (never a link); the other items are
+ * links when they have an `href` (or `clickable: true`), otherwise plain text.
+ */
 export interface SirioBreadcrumbItem {
   label: string;
-  /** Link of the item; without it the item emits `(itemClick)` (e.g. for router navigation). */
+  /** Link of the item; without it the item is plain text (unless `clickable: true`). */
   href?: string;
   /** Font Awesome icon before the label (kit: `fa-home`). */
   icon?: string;
+  /**
+   * Overrides the default (clickable only with an `href`): `true` renders a link without `href`
+   * that only emits `(itemClick)` (e.g. for router navigation), `false` renders plain text even
+   * with an `href`.
+   */
+  clickable?: boolean;
 }
 /** Payload of `(itemClick)`. */
 export interface SirioBreadcrumbClick {
@@ -1573,7 +1615,8 @@ export interface SirioBreadcrumbClick {
  * ]" />
  * ```
  *
- * For router navigation leave `href` empty (or prevent it) and navigate in `(itemClick)`.
+ * Items without `href` are plain text. For router navigation set the `href` and call
+ * `event.preventDefault()` in `(itemClick)`, or use `clickable: true` without `href`.
  */
 export declare class SirioBreadcrumb {
   readonly items: import("@angular/core").InputSignal<SirioBreadcrumbItem[]>;
@@ -1601,6 +1644,8 @@ export declare class SirioBreadcrumb {
   constructor();
   /** Shows the whole path (kit "..." button) and moves the focus to the first restored link. */
   expand(): void;
+  /** Clickable item: explicit `clickable`, otherwise only when it has an `href`. */
+  protected isLink(item: SirioBreadcrumbItem): boolean;
   protected onClick(item: SirioBreadcrumbItem, index: number, event: MouseEvent): void;
   protected iconClasses(icon: string): string;
   /** Kit: expand, then truncate again if the full path wraps. */
@@ -1804,9 +1849,11 @@ export declare class SirioPendingIndicator {
  * Layouts of the Sirio pagination:
  * - `full`: kit "Paginazione con alto numero di pagine" (elements per page, range, page select,
  *   previous/next);
- * - `numbers`: page numbers with ellipsis (kit `.sirio-pagination-center` > `.sirio-pagination-list`).
+ * - `numbers`: page numbers with ellipsis (kit `.sirio-pagination-center` > `.sirio-pagination-list`);
+ * - `compact`: the `full` row in a single thin bar for tables (smaller fields and buttons, "Pagina 1
+ *   di 6" as text, first / previous / next / last).
  */
-export type SirioPaginationVariant = 'full' | 'numbers';
+export type SirioPaginationVariant = 'full' | 'numbers' | 'compact';
 /** Payload of `(paged)`. */
 export interface SirioPageEvent {
   /** Current page (1-based). */
@@ -1849,6 +1896,12 @@ export declare class SirioPagination {
   readonly variant: import("@angular/core").InputSignal<SirioPaginationVariant>;
   /** Total number of items. */
   readonly total: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * The real total is not known yet: there are more items after `total` (the items known so far,
+   * e.g. a server without a count). "Successiva" stays active on the last known page and the totals
+   * are shown as "30+" ("oltre 30" for screen readers).
+   */
+  readonly hasMore: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Current page, 1-based (two-way: `[(page)]`). */
   readonly page: import("@angular/core").ModelSignal<number>;
   /** Items per page (two-way: `[(pageSize)]`). */
@@ -1876,18 +1929,28 @@ export declare class SirioPagination {
   readonly pageLabel: import("@angular/core").InputSignal<string>;
   readonly previousLabel: import("@angular/core").InputSignal<string>;
   readonly nextLabel: import("@angular/core").InputSignal<string>;
+  /** First / last page buttons of the `compact` variant. */
+  readonly firstLabel: import("@angular/core").InputSignal<string>;
+  readonly lastLabel: import("@angular/core").InputSignal<string>;
+  /** Read before an open total (`hasMore`): "di oltre 30 elementi". */
+  readonly moreLabel: import("@angular/core").InputSignal<string>;
   /** Emitted when the user changes page or page size. */
   readonly paged: import("@angular/core").OutputEmitterRef<SirioPageEvent>;
   private readonly baseId;
   protected readonly sizeId: string;
   protected readonly pageId: string;
+  /** Pages known (with `hasMore` the next one can also be reached). */
   readonly pageCount: import("@angular/core").Signal<number>;
+  /** Last page that can be reached: one more than the known ones with `hasMore`. */
+  private readonly lastPage;
   protected readonly pages: import("@angular/core").Signal<number[]>;
   protected readonly rangeStart: import("@angular/core").Signal<number>;
   protected readonly rangeEnd: import("@angular/core").Signal<number>;
   /** Page select and previous/next of `full`: hidden when there is nothing to navigate without the items block. */
   protected readonly showPages: import("@angular/core").Signal<boolean>;
   protected readonly status: import("@angular/core").Signal<string>;
+  /** Previous / next disabled at the ends (next stays active while more items exist). */
+  protected readonly atEnd: import("@angular/core").Signal<boolean>;
   /** Numbered list: first, last, current ± siblings, ellipsis for the gaps. */
   protected readonly entries: import("@angular/core").Signal<PageEntry[]>;
   constructor();
@@ -1911,6 +1974,11 @@ export declare class SirioPagination {
       "required": false;
       "isSignal": true;
     };
+    "hasMore": {
+      "alias": "hasMore";
+      "required": false;
+      "isSignal": true;
+    };
     "page": {
       "alias": "page";
       "required": false;
@@ -1991,21 +2059,2567 @@ export declare class SirioPagination {
       "required": false;
       "isSignal": true;
     };
-    "previousLabel": {
-      "alias": "previousLabel";
+    "previousLabel": {
+      "alias": "previousLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nextLabel": {
+      "alias": "nextLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "firstLabel": {
+      "alias": "firstLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "lastLabel": {
+      "alias": "lastLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "moreLabel": {
+      "alias": "moreLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "page": "pageChange";
+    "pageSize": "pageSizeChange";
+    "paged": "paged";
+  }, never, ["*"], true, never>;
+}
+/** Sort direction of a column. */
+export type SirioSortDirection = 'asc' | 'desc';
+/** A sort criterion of the grid (`[(sort)]` is the list of criteria in priority order). */
+export interface SirioGridSort {
+  /** Sort key of the column (`sortKey`, or its `field`). */
+  field: string;
+  direction: SirioSortDirection;
+}
+/** Request sent to a server side data source. */
+export interface SirioGridQuery {
+  /** Current page, 1-based. */
+  page: number;
+  pageSize: number;
+  /** Index of the first row of the page (0-based), e.g. for `$skip` / `OFFSET`. */
+  offset: number;
+  /** Sort criteria in priority order; empty = no sort. */
+  sort: SirioGridSort[];
+  /** Active column filters by filter key (see `SirioGridFilters`); empty object = no filter. */
+  filters: SirioGridFilters;
+}
+/**
+ * Filter of a column (`wm-sirio-grid-column [filter]`), edited with the controls of the library:
+ * - `text`: `wm-sirio-textbox`, rows whose cell text contains the value (case and accent insensitive);
+ * - `number`: two `wm-sirio-number` (from / to), value `SirioGridRange<number>`;
+ * - `date`: two `wm-sirio-date` (from / to), value `SirioGridRange<string>` with 'yyyy-MM-dd';
+ * - `select`: `wm-sirio-select` with `filterOptions` (one value, or an array with `filterMultiple`);
+ * - `boolean`: `wm-sirio-select` Sì / No, value `true` / `false`.
+ */
+export type SirioGridFilterType = 'text' | 'number' | 'date' | 'select' | 'boolean';
+/** Value of a range filter (`number`, `date`); a missing bound is open. */
+export interface SirioGridRange<T = number | string> {
+  from?: T | null;
+  to?: T | null;
+}
+/**
+ * Operator of a filter condition (`filterOperators`):
+ * - text: `contains`, `notContains`, `equals`, `notEquals`, `startsWith`, `endsWith`;
+ * - number: `equals`, `notEquals`, `greaterThan`, `greaterThanOrEqual`, `lessThan`,
+ *   `lessThanOrEqual`, `between` (`value` and `to` included);
+ * - date ('yyyy-MM-dd'): `equals`, `notEquals`, `before`, `after`, `between`;
+ * - select: `in`, `notIn` (one value or an array);
+ * - boolean: `equals`;
+ * - every type: `blank`, `notBlank` (no value).
+ */
+export type SirioGridFilterOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between' | 'before' | 'after' | 'in' | 'notIn' | 'blank' | 'notBlank';
+/**
+ * Filter value of a column with operators: `{ operator: 'greaterThan', value: 1000 }`,
+ * `{ operator: 'between', value: '2026-01-01', to: '2026-03-31' }`, `{ operator: 'blank' }`.
+ */
+export interface SirioGridFilterCondition<V = unknown> {
+  operator: SirioGridFilterOperator;
+  value?: V | null;
+  /** Upper bound of `between`. */
+  to?: V | null;
+}
+/** Operators of each filter type, in the order of the choice; the first one is the default. */
+export declare const SIRIO_GRID_FILTER_OPERATORS: Readonly<Record<SirioGridFilterType, readonly SirioGridFilterOperator[]>>;
+/** The value is a filter condition (`{ operator, value?, to? }`). */
+export declare function sirioIsFilterCondition(value: unknown): value is SirioGridFilterCondition;
+/** Column filters by filter key (`filterKey` of the column, default its sort key / field). */
+export type SirioGridFilters = Record<string, unknown>;
+/** True when a filter value restricts the rows (not empty, not an empty range or list). */
+export declare function sirioGridFilterActive(value: unknown): boolean;
+/** Only the active filters (the object sent to a server data source). */
+export declare function sirioActiveGridFilters(filters: SirioGridFilters | null | undefined): SirioGridFilters;
+/** Response of a server side data source: the rows of the page and the total number of rows. */
+export interface SirioGridResult<T> {
+  rows: readonly T[];
+  /**
+   * Rows that pass the filters on the server. Without it (null / undefined) the total is open: a
+   * full page means there are more rows ("Successiva" active, totals as "30+"), a shorter page is
+   * the last one.
+   */
+  total?: number | null;
+}
+/**
+ * Server side data source: receives the query (page, page size, sort, filters) and returns the page.
+ * Called again whenever the query changes and on `reload()`; responses of outdated queries are
+ * ignored.
+ *
+ * ```ts
+ * readonly load: SirioGridDataSource<Pratica> = (q) =>
+ *   this.http.get<SirioGridResult<Pratica>>('/api/pratiche', { params: { ... } });
+ * ```
+ */
+export type SirioGridDataSource<T> = (query: SirioGridQuery) => Observable<SirioGridResult<T>> | Promise<SirioGridResult<T>> | SirioGridResult<T>;
+/** Sort on one column at a time (`single`) or on more columns with Shift+click (`multiple`). */
+export type SirioGridSortMode = 'single' | 'multiple';
+/** Aggregation of a column in the group rows (`wm-sirio-grid-column [aggregate]`). */
+export type SirioGridAggregate = 'sum' | 'mean' | 'min' | 'max' | 'count';
+/**
+ * Expanded rows by row id (the `rowId` value as text; group rows: `<column>:<value>`), or `true`
+ * for every row (two-way: `[(expanded)]`).
+ */
+export type SirioGridExpanded = Record<string, boolean> | true;
+/** Sub-rows of a row for tree data: the name of a property or a function. */
+export type SirioGridSubRows<T> = string | ((row: T) => readonly T[] | null | undefined);
+/**
+ * State of a grid chosen by the user, to save it and restore it when the page opens again
+ * (`getState()` / `setState()` / `(stateChange)`); plain JSON.
+ */
+export interface SirioGridState {
+  /** Version of the format, for future migrations. */
+  version: 1;
+  sort: SirioGridSort[];
+  filters: SirioGridFilters;
+  page: number;
+  pageSize: number;
+  /** Column keys in display order (empty = declaration order). */
+  columnOrder: string[];
+  /** Widths (px) of the resized columns by key. */
+  columnWidths: Record<string, number>;
+  grouping: string[];
+  expanded: SirioGridExpanded;
+  /** `rowId` of the selected rows (only with a `rowId` giving texts or numbers). */
+  selected?: (string | number)[];
+}
+/** Row selection mode. */
+export type SirioGridSelection = 'none' | 'single' | 'multiple';
+/** Look of the table (kit classes `sirio-table-dark` / `sirio-table-light`). */
+export type SirioGridVariant = 'default' | 'dark' | 'striped';
+/** Density of the cells (kit classes `sirio-table-xs` / `-sm` / `-lg`). */
+export type SirioGridSize = 'xs' | 'sm' | 'md' | 'lg';
+/**
+ * Rows taken by "seleziona tutto" (header checkbox of the multiple selection): `page` the rows of the
+ * current page, `filtered` every row that passes the filters (all the pages), `all` every row, also
+ * the ones excluded by the filters. With a server data source only the loaded page is available.
+ */
+export type SirioGridSelectAll = 'page' | 'filtered' | 'all';
+/** Horizontal alignment of a column (header and cells). */
+export type SirioGridAlign = 'start' | 'center' | 'end';
+/**
+ * Side where a column stays fixed during the horizontal scroll (`wm-sirio-grid-column fixed`).
+ * More columns can be fixed on both sides; the fixed columns are shown at that side of the table.
+ */
+export type SirioGridFixed = 'left' | 'right';
+/** Identity of a row: the name of a property or a function. null = the row object itself. */
+export type SirioGridRowId<T> = string | ((row: T) => unknown) | null;
+/** Payload of `(rowClick)`. */
+export interface SirioGridRowEvent<T> {
+  row: T;
+  /** Index of the row in the current page (0-based). */
+  index: number;
+  event: MouseEvent | KeyboardEvent;
+}
+/**
+ * Reads a property by path (`'indirizzo.citta'`); undefined when a step is missing.
+ * @internal
+ */
+export declare function sirioReadPath(row: unknown, path: string): unknown;
+/**
+ * Text normalized for the `text` filter: lower case, without accents and repeated spaces.
+ * @internal
+ */
+export declare function sirioNormalizeText(value: unknown): string;
+/**
+ * 'yyyy-MM-dd' of a cell value for the `date` filter: a Date (local day) or the start of an ISO
+ * string; null when the value is not a date.
+ * @internal
+ */
+export declare function sirioIsoDay(value: unknown): string | null;
+/**
+ * Default comparison of two cell values: null/undefined last, numbers and dates by value,
+ * booleans false before true, the rest as text with the collation of `locale` (numeric aware;
+ * the grid passes its `LOCALE_ID`, default the browser language).
+ */
+export declare function sirioDefaultGridCompare(a: unknown, b: unknown, locale?: string): number;
+/**
+ * Classes of rows, cells and headers, as with `ngClass`: a text (`'a b'`), a list (`['a', 'b']`)
+ * or an object `{ classe: condizione }` (classes with a true condition).
+ */
+export type SirioGridClass = string | readonly string[] | Readonly<Record<string, unknown>> | null | undefined;
+/**
+ * Inline styles of rows, cells and headers, as with `ngStyle`: CSS text (`'color: red'`) or an
+ * object `{ proprietà: valore }` (camelCase or kebab-case names, unit in the key: `'width.px': 80`).
+ */
+export type SirioGridStyle = string | Readonly<Record<string, string | number | null | undefined>> | null | undefined;
+/** Classes or styles of a row: fixed, or a function of the row and its index in the page. */
+export type SirioGridRowClass<T> = SirioGridClass | ((row: T, index: number) => SirioGridClass);
+export type SirioGridRowStyle<T> = SirioGridStyle | ((row: T, index: number) => SirioGridStyle);
+/** Classes or styles of the cells of a column: fixed, or a function of the row and of the cell value. */
+export type SirioGridCellClass<T> = SirioGridClass | ((row: T, value: unknown) => SirioGridClass);
+export type SirioGridCellStyle<T> = SirioGridStyle | ((row: T, value: unknown) => SirioGridStyle);
+/**
+ * Class names of a `SirioGridClass`, separated by spaces ('' when none).
+ * @internal
+ */
+export declare function sirioGridClassText(value: SirioGridClass): string;
+/**
+ * Style object of a `SirioGridStyle` (kebab-case names, units applied; empty values dropped),
+ * null when there are no styles.
+ * @internal
+ */
+export declare function sirioGridStyleObject(value: SirioGridStyle): Record<string, string> | null;
+/**
+ * Predefined formats of `wm-sirio-grid-column [format]` (all in the format of `LOCALE_ID`):
+ * - `number`: 1.234,5 (decimals / grouping options);
+ * - `currency`: 1.234,50 € (`currency`, default EUR);
+ * - `percentage`: 15 % from 0.15 (`scale: 'percent'` when the value is already 15);
+ * - `date`: 31/01/2026 (`precision`: `day`, `month` → 01/2026, `year` → 2026);
+ * - `dateTime`: 31/01/2026 14:30 (`seconds`);
+ * - `time`: 14:30 (`seconds`);
+ * - `boolean`: Sì / No (`trueLabel`, `falseLabel`);
+ * - `map`: a code shown with its label (`values`: object or `SirioOption[]`).
+ */
+export type SirioGridFormatName = 'number' | 'currency' | 'percentage' | 'date' | 'dateTime' | 'time' | 'boolean' | 'map';
+/** Options of the predefined formats (`wm-sirio-grid-column [formatOptions]`). */
+export interface SirioGridFormatOptions {
+  /** Text of an empty value (null, undefined, ''); default ''. */
+  empty?: string;
+  /** Number of decimals (fixed) of `number`, `currency`, `percentage`. */
+  decimals?: number;
+  /** Minimum / maximum decimals of `number`, `currency`, `percentage` (instead of `decimals`). */
+  minDecimals?: number;
+  maxDecimals?: number;
+  /** Thousands separator of `number`, `currency` (rule of the locale); false = none. */
+  grouping?: boolean;
+  /** ISO 4217 code of `currency`; default 'EUR'. */
+  currency?: string;
+  /** Unit of the `percentage` value: `fraction` (0.15 = 15 %, default) or `percent` (15 = 15 %). */
+  scale?: 'fraction' | 'percent';
+  /** What `date` shows: the day (default), the month or the year. */
+  precision?: 'day' | 'month' | 'year';
+  /** Seconds in `dateTime` and `time`. */
+  seconds?: boolean;
+  /** Labels of `boolean`; default "Sì" / "No". */
+  trueLabel?: string;
+  falseLabel?: string;
+  /** Labels of `map`: `{ A: 'Aperta' }` or `[{ value: 'A', label: 'Aperta' }]`. */
+  values?: Readonly<Record<string, string>> | readonly SirioOption[];
+  /** Options of the formats registered with `provideSirioGridFormats`. */
+  [option: string]: unknown;
+}
+/** A named format: the text of a value (row undefined for group rows and filter values). */
+export type SirioGridFormatFn = (value: unknown, row: unknown, options: SirioGridFormatOptions, locale: string) => string;
+/** Configuration of `provideSirioGridFormats`. */
+export interface SirioGridFormatsConfig {
+  /** Options of every format (e.g. `{ empty: '—', currency: 'EUR' }`). */
+  defaults?: SirioGridFormatOptions;
+  /** Options of a single format, over `defaults` (e.g. `{ percentage: { decimals: 1 } }`). */
+  formatDefaults?: Partial<Record<string, SirioGridFormatOptions>>;
+  /** Formats added (or predefined ones replaced) by name. */
+  formats?: Record<string, SirioGridFormatFn>;
+}
+/** @internal */
+export declare const SIRIO_GRID_FORMATS: InjectionToken<SirioGridFormatsConfig>;
+/**
+ * Formats of the grid columns for the whole application (or part of it): default options and
+ * formats by name, used as `format="nome"` on the columns.
+ *
+ * ```ts
+ * providers: [
+ *   provideSirioGridFormats({
+ *     defaults: { empty: '—' },
+ *     formatDefaults: { currency: { currency: 'EUR', decimals: 2 } },
+ *     formats: { codiceFiscale: (v) => String(v ?? '').toUpperCase() },
+ *   }),
+ * ]
+ * ```
+ */
+export declare function provideSirioGridFormats(config: SirioGridFormatsConfig): EnvironmentProviders;
+/** Kind of a predefined format: numbers and dates are aligned / sorted / shown as such. */
+export type SirioGridFormatKind = 'number' | 'date' | null;
+/** @internal */
+export declare function sirioGridFormatKind(name: string | null): SirioGridFormatKind;
+/**
+ * Number of a cell value: numbers, bigints and numeric texts ('1234.5'); NaN otherwise.
+ * @internal
+ */
+export declare function sirioGridToNumber(value: unknown): number;
+/**
+ * Date of a cell value: `Date`, milliseconds, ISO texts ('2026-01-31' as a local day,
+ * '2026-01-31T14:30' local, with an offset as given) and times ('14:30', today); null otherwise.
+ * @internal
+ */
+export declare function sirioGridToDate(value: unknown): Date | null;
+/**
+ * Text function of a named format with its options (registered formats first, then the
+ * predefined ones); null for an unknown name. Empty values give `options.empty`.
+ * @internal
+ */
+export declare function sirioGridNamedFormat(name: string, options: SirioGridFormatOptions | null, config: SirioGridFormatsConfig | null, locale: string): ((value: unknown, row: unknown) => string) | null;
+/**
+ * Choices of a `map` format for a select filter: every code of `values` with its label.
+ * @internal
+ */
+export declare function sirioGridMapOptions(values: SirioGridFormatOptions['values']): SirioOption[];
+/** Context of a `wmSirioGridCell` template. */
+export interface SirioGridCellContext<T = any> {
+  /** The row. */
+  $implicit: T;
+  row: T;
+  /** Value of the column for the row (`value` function or `field`). */
+  value: unknown;
+  /** Index of the row in the current page (0-based). */
+  index: number;
+}
+/** Context of a `wmSirioGridHeader` template. */
+export interface SirioGridHeaderContext {
+  /** The column. */
+  $implicit: SirioGridColumn;
+}
+/**
+ * Custom cell of a column:
+ * `<ng-template wmSirioGridCell let-row let-value="value">{{ value | currency: 'EUR' }}</ng-template>`.
+ */
+export declare class SirioGridCell {
+  static ngTemplateContextGuard(_dir: SirioGridCell, ctx: unknown): ctx is SirioGridCellContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridCell, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridCell, "ng-template[wmSirioGridCell]", never, {}, {}, never, never, true, never>;
+}
+/** Custom header of a column (rich content instead of the `header` text). */
+export declare class SirioGridHeader {
+  static ngTemplateContextGuard(_dir: SirioGridHeader, ctx: unknown): ctx is SirioGridHeaderContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridHeader, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridHeader, "ng-template[wmSirioGridHeader]", never, {}, {}, never, never, true, never>;
+}
+/** Context of a `wmSirioGridDetail` template. */
+export interface SirioGridDetailContext<T = any> {
+  /** The row. */
+  $implicit: T;
+  row: T;
+}
+/**
+ * Detail panel of an expandable row, shown below it when expanded (the grid adds the expand
+ * column): `<ng-template wmSirioGridDetail let-row>...</ng-template>` inside `wm-sirio-data-grid`.
+ */
+export declare class SirioGridDetail {
+  static ngTemplateContextGuard(_dir: SirioGridDetail, ctx: unknown): ctx is SirioGridDetailContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridDetail, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridDetail, "ng-template[wmSirioGridDetail]", never, {}, {}, never, never, true, never>;
+}
+/** Content of the grid when there are no rows (instead of the `emptyText` text). */
+export declare class SirioGridEmpty {
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridEmpty, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridEmpty, "ng-template[wmSirioGridEmpty]", never, {}, {}, never, never, true, never>;
+}
+/** Context of a `wmSirioGridError` template. */
+export interface SirioGridErrorContext {
+  /** Error of the data source. */
+  $implicit: unknown;
+  error: unknown;
+  /** Calls the data source again (as `reload()`). */
+  retry: () => void;
+}
+/**
+ * Content of the grid when the server data source fails (instead of the `loadErrorText` message
+ * with "Riprova"): `<ng-template wmSirioGridError let-error let-retry="retry">...</ng-template>`.
+ */
+export declare class SirioGridError {
+  static ngTemplateContextGuard(_dir: SirioGridError, ctx: unknown): ctx is SirioGridErrorContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridError, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridError, "ng-template[wmSirioGridError]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Column of `wm-sirio-data-grid`. Renders nothing by itself: it describes the column (value,
+ * header, sorting, alignment, width) and holds its optional cell/header templates.
+ *
+ * ```html
+ * <wm-sirio-grid-column field="nome" header="Nome" sortable />
+ * <wm-sirio-grid-column field="importo" header="Importo" align="end" [format]="euro" filter="number" />
+ * <wm-sirio-grid-column field="stato" header="Stato" filter="select" [filterOptions]="stati" />
+ * ```
+ */
+export declare class SirioGridColumn<T = any> {
+  /** Property of the row shown in the column; dotted paths are allowed (`indirizzo.citta`). */
+  readonly field: import("@angular/core").InputSignal<string>;
+  /** Header text (also the label of the cell in the card layout). */
+  readonly header: import("@angular/core").InputSignal<string>;
+  /** Click on the header sorts by this column (asc → desc → none). */
+  readonly sortable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Key of the sort (`SirioGridSort.field`, sent to a server data source); default `field`. */
+  readonly sortKey: import("@angular/core").InputSignal<string | null>;
+  /** Alignment of header and cells; default `end` for the number formats, `start` otherwise. */
+  readonly align: import("@angular/core").InputSignal<SirioGridAlign | null>;
+  /** CSS width of the column (`120px`, `20%`); null = automatic. */
+  readonly width: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Share of the free width of the grid taken by the column, as `flex` in CSS / ag-grid: the
+   * columns with `flex` fill the width left by the others in proportion (`flex="2"` takes twice
+   * `flex="1"`), within `minWidth` / `maxWidth`. `flex` without a value = 1. The other columns keep
+   * their `width`, or their content width.
+   */
+  readonly flex: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Long texts wrap on more lines (default). With `false` the cell text stays on one line: the
+   * column widens, or the text is cut with an ellipsis when the column has a width.
+   */
+  readonly wrap: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * The column is as wide as its content (as the actions column): it does not take a share of the
+   * free room of the table, and its cells stay on one line (e.g. a row of buttons).
+   */
+  readonly fit: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Group of the column in the grouped headers: the group names from the top level down, separated
+   * by `/` (or `\`), e.g. `"Pratica"` or `"Dati/Richiedente"`. Adjacent columns with the same groups
+   * share the group header cells; null = no group.
+   */
+  readonly group: import("@angular/core").InputSignal<string | null>;
+  /**
+   * The column stays fixed at the left or right side during the horizontal scroll of the kit
+   * responsive container (more columns can be fixed on both sides); null = it scrolls.
+   */
+  readonly fixed: import("@angular/core").InputSignalWithTransform<SirioGridFixed | null, "" | SirioGridFixed | null | undefined>;
+  /** Value of the cell computed from the row (instead of `field`); also used for sorting. */
+  readonly value: import("@angular/core").InputSignal<((row: T) => unknown) | null>;
+  /**
+   * Text of the cell from its value: a function `(value, row) => string`, or the name of a
+   * predefined format (`number`, `currency`, `percentage`, `date`, `dateTime`, `time`, `boolean`,
+   * `map`, see `SirioGridFormatName`, options in `formatOptions`) or of a format registered with
+   * `provideSirioGridFormats`. Default: numbers with the decimal separator of `LOCALE_ID` (no
+   * thousands grouping, so codes and years stay as they are), `Date` values as a date of
+   * `LOCALE_ID`, the rest as `String(value)`.
+   */
+  readonly format: import("@angular/core").InputSignal<SirioGridFormatName | (string & {}) | ((value: unknown, row: T) => string) | null>;
+  /** Options of a named `format` (see `SirioGridFormatOptions`), over the `provideSirioGridFormats` defaults. */
+  readonly formatOptions: import("@angular/core").InputSignal<SirioGridFormatOptions | null>;
+  /** Comparison used by the client side sort; default `sirioDefaultGridCompare`. */
+  readonly compare: import("@angular/core").InputSignal<((a: unknown, b: unknown) => number) | null>;
+  /** The rows can be grouped by this column ("Raggruppa per" of the grid, `[(grouping)]`). */
+  readonly groupable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Value of the column in the group rows: sum, mean, min, max or count of the grouped rows. */
+  readonly aggregate: import("@angular/core").InputSignal<SirioGridAggregate | null>;
+  /** With a `resizable` grid: false keeps the width of this column fixed. */
+  readonly resizable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Minimum width in pixels when resized. */
+  readonly minWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Maximum width in pixels when resized; null = none. */
+  readonly maxWidth: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+  /**
+   * Classes of the cells: text, list or object `{ classe: condizione }`, or a function of the row
+   * and of the cell value (e.g. `(row, value) => ({ 'sirio-text-danger': value < 0 })`).
+   */
+  readonly cellClass: import("@angular/core").InputSignal<SirioGridCellClass<T>>;
+  /** Inline styles of the cells: CSS text or object, or a function of the row and of the cell value. */
+  readonly cellStyle: import("@angular/core").InputSignal<SirioGridCellStyle<T>>;
+  /** Classes of the header cell (text, list or object). */
+  readonly headerClass: import("@angular/core").InputSignal<SirioGridClass>;
+  /** Inline styles of the header cell (CSS text or object). */
+  readonly headerStyle: import("@angular/core").InputSignal<SirioGridStyle>;
+  /** Filter of the column, edited in the popover of its header (see `SirioGridFilterType`); null = none. */
+  readonly filter: import("@angular/core").InputSignal<SirioGridFilterType | null>;
+  /** Key of the filter (`SirioGridFilters`, sent to a server data source); default the sort key. */
+  readonly filterKey: import("@angular/core").InputSignal<string | null>;
+  /** Options of a `select` filter. */
+  readonly filterOptions: import("@angular/core").InputSignal<SirioOption<unknown>[]>;
+  /** `select` filter with more values (rows matching any of them). */
+  readonly filterMultiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Placeholder of a `text` filter. */
+  readonly filterPlaceholder: import("@angular/core").InputSignal<string>;
+  /** Client side match of a row (instead of the default one of the filter type). */
+  readonly filterPredicate: import("@angular/core").InputSignal<((value: unknown, filter: unknown, row: T) => boolean) | null>;
+  /**
+   * Operators of the filter (a "Condizione" choice above the value, the value becomes a
+   * `SirioGridFilterCondition`): true = every operator of the filter type, a list = those
+   * operators (see `SIRIO_GRID_FILTER_OPERATORS`), false = none; null (default) = the grid
+   * `filterOperators`.
+   */
+  readonly filterOperators: import("@angular/core").InputSignalWithTransform<boolean | readonly SirioGridFilterOperator[] | null, unknown>;
+  /** Operators offered for the filter (empty = simple filter without operators). @internal */
+  operatorsFor(gridDefault: boolean): readonly SirioGridFilterOperator[];
+  /** @internal */
+  readonly cellTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  /** @internal */
+  readonly headerTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  /** Key used in `SirioGridSort.field`. */
+  readonly key: import("@angular/core").Signal<string>;
+  /** Group names of `group`, top level first (empty = no group). */
+  readonly groupPath: import("@angular/core").Signal<string[]>;
+  /**
+   * Key used in `SirioGridFilters` for a column alone on its field; the grid makes it unique for
+   * columns on the same field (see `SirioDataGrid.filterIdOf`).
+   */
+  readonly filterId: import("@angular/core").Signal<string>;
+  /** Value of the column for a row. */
+  valueOf(row: T): unknown;
+  /** Initial width in pixels from `width` (`'160px'`); null when it is not a pixel value. */
+  readonly widthPx: import("@angular/core").Signal<number | null>;
+  private readonly locale;
+  private readonly formats;
+  /** Name of the `format` when it is a predefined / registered format. */
+  readonly formatName: import("@angular/core").Signal<SirioGridFormatName | (string & {}) | null>;
+  /** Numbers or dates by their predefined format (alignment, font, sort). */
+  readonly formatKind: import("@angular/core").Signal<import("@wemake4u/form-controls").SirioGridFormatKind>;
+  /** Effective alignment: `align`, or `end` for the number formats. */
+  readonly alignment: import("@angular/core").Signal<SirioGridAlign>;
+  /** Text function of `format` (a function or a named format); null = default text. */
+  private readonly formatter;
+  private readonly numberText;
+  private readonly dateText;
+  /** Default text of a value without `format`: numbers and dates of `LOCALE_ID`. */
+  private defaultText;
+  /** Text of a value of the column without a row (group rows, filter values). */
+  formatValue(value: unknown): string;
+  /** Text of the cell for a row (cells without a template). */
+  textOf(row: T): string;
+  /**
+   * Default comparison of the client side sort: by number / date for the number and date formats
+   * (also when the values are texts), otherwise `sirioDefaultGridCompare` with the locale.
+   * @internal
+   */
+  compareValues(a: unknown, b: unknown): number;
+  /** True when the row passes the filter value of this column (client side filtering). */
+  matches(row: T, filter: unknown): boolean;
+  /** Client side match of a filter condition. */
+  private matchesCondition;
+  /**
+   * Numbers in the kit font (`font-mono`, Roboto Mono, as the kit numeric fields, dates and
+   * pagination): true / false forces it; null (default) = numeric and date cells, i.e. columns
+   * with a `number` / `date` filter or with a number / `Date` value.
+   */
+  readonly mono: import("@angular/core").InputSignalWithTransform<boolean | null, unknown>;
+  /** The cell of a row is shown in the kit numbers font (see `mono`). @internal */
+  isMono(row: T): boolean;
+  /** @internal */
+  /** Class names of a cell (`cellClass`), '' when none. */
+  classOf(row: T): string;
+  /** Inline styles of a cell (`cellStyle`), null when none. */
+  styleOf(row: T): Record<string, string> | null;
+  /** Class names of the header cell (`headerClass`). */
+  readonly headerClassText: import("@angular/core").Signal<string>;
+  /** Inline styles of the header cell (`headerStyle`). */
+  readonly headerStyleObject: import("@angular/core").Signal<Record<string, string> | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridColumn<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SirioGridColumn<any>, "wm-sirio-grid-column", never, {
+    "field": {
+      "alias": "field";
+      "required": false;
+      "isSignal": true;
+    };
+    "header": {
+      "alias": "header";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortable": {
+      "alias": "sortable";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortKey": {
+      "alias": "sortKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "width": {
+      "alias": "width";
+      "required": false;
+      "isSignal": true;
+    };
+    "flex": {
+      "alias": "flex";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "wrap": {
+      "alias": "wrap";
+      "required": false;
+      "isSignal": true;
+    };
+    "fit": {
+      "alias": "fit";
+      "required": false;
+      "isSignal": true;
+    };
+    "group": {
+      "alias": "group";
+      "required": false;
+      "isSignal": true;
+    };
+    "fixed": {
+      "alias": "fixed";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+    "formatOptions": {
+      "alias": "formatOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "compare": {
+      "alias": "compare";
+      "required": false;
+      "isSignal": true;
+    };
+    "groupable": {
+      "alias": "groupable";
+      "required": false;
+      "isSignal": true;
+    };
+    "aggregate": {
+      "alias": "aggregate";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizable": {
+      "alias": "resizable";
+      "required": false;
+      "isSignal": true;
+    };
+    "minWidth": {
+      "alias": "minWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxWidth": {
+      "alias": "maxWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "cellClass": {
+      "alias": "cellClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "cellStyle": {
+      "alias": "cellStyle";
+      "required": false;
+      "isSignal": true;
+    };
+    "headerClass": {
+      "alias": "headerClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "headerStyle": {
+      "alias": "headerStyle";
+      "required": false;
+      "isSignal": true;
+    };
+    "filter": {
+      "alias": "filter";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterKey": {
+      "alias": "filterKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterOptions": {
+      "alias": "filterOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterMultiple": {
+      "alias": "filterMultiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterPlaceholder": {
+      "alias": "filterPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterPredicate": {
+      "alias": "filterPredicate";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterOperators": {
+      "alias": "filterOperators";
+      "required": false;
+      "isSignal": true;
+    };
+    "mono": {
+      "alias": "mono";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["cellTemplate", "headerTemplate"], never, true, never>;
+}
+/**
+ * Builds the form group of a row of a `[formArray]` grid, with its validators: from the value of an
+ * existing row (copy edited in the dialog) or from null / the initial values of a new row.
+ */
+export type SirioGridRowFactory<T extends object = any> = (value: T | null) => FormGroup;
+/** Context of the `wmSirioGridEditor` template (form of the edit dialog). */
+export interface SirioGridEditorContext<T extends object = any> {
+  /** Form group to bind (`[formGroup]="group"`): a copy of the row, applied by "Salva". */
+  $implicit: FormGroup;
+  group: FormGroup;
+  /** Value of the row being edited; null for a new row. */
+  row: T | null;
+  /** New row ("Aggiungi"). */
+  isNew: boolean;
+  /** Dialog opened to view the row (form array or row disabled, `rowEditable` false). */
+  readonly: boolean;
+}
+/** `(rowSave)` and `saveHandler`: a row saved from the edit dialog. */
+export interface SirioGridRowSaveEvent<T extends object = any> {
+  /** New value of the row. */
+  row: T;
+  /** Value before the change; null for a new row. */
+  previous: T | null;
+  /**
+   * Form group of the row: for `saveHandler` the edited copy (not applied yet), for `(rowSave)` the
+   * group of the form array (the copy itself for a new row).
+   */
+  group: FormGroup;
+  isNew: boolean;
+  /** Position in the form array (for a new row: the position it takes, at the end). */
+  index: number;
+}
+/** `(rowDelete)` and `deleteHandler`: a row removed from the form array. */
+export interface SirioGridRowDeleteEvent<T extends object = any> {
+  row: T;
+  group: FormGroup;
+  index: number;
+}
+/**
+ * Check before applying a change (e.g. a call to the server): false, an exception or a rejected
+ * promise / observable keep the change from happening (the edit dialog stays open with the error).
+ */
+export type SirioGridChangeHandler<E> = (event: E) => boolean | void | Promise<boolean | void> | Observable<boolean | void>;
+/**
+ * Form of the edit dialog of a `[formArray]` grid, bound to the copy of the row:
+ *
+ * ```html
+ * <ng-template wmSirioGridEditor let-group let-isNew="isNew">
+ *   <div [formGroup]="group">
+ *     <wm-sirio-textbox formControlName="descrizione" label="Descrizione" />
+ *   </div>
+ * </ng-template>
+ * ```
+ */
+export declare class SirioGridEditor<T extends object = any> {
+  static ngTemplateContextGuard<T extends object>(_dir: SirioGridEditor<T>, ctx: unknown): ctx is SirioGridEditorContext<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridEditor<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridEditor<any>, "ng-template[wmSirioGridEditor]", never, {}, {}, never, never, true, never>;
+}
+/** Default messages of the form array errors (the global ones talk about characters). */
+export declare const SIRIO_GRID_ARRAY_MESSAGES: SirioErrorMessages;
+/**
+ * Copy of a control with the same structure, values, disabled state, validators (the composed
+ * validator functions) and `updateOn`: the form edited in the dialog when there is no `rowFactory`.
+ * @internal
+ */
+export declare function sirioCloneControl<C extends AbstractControl>(control: C): C;
+/**
+ * Writes the values of `source` into `target` (same structure): nested form arrays get the rows
+ * added / removed in the dialog (copies of the source controls). Returns true when something changed.
+ * @internal
+ */
+export declare function sirioSyncControl(target: AbstractControl, source: AbstractControl): boolean;
+/** Sizes of the kit dialog (`.sirio-dialog-wrapper` modifiers); default 600px. */
+export type SirioDialogSize = 'sm' | 'default' | 'lg' | 'xl';
+/** Color of the title icon (kit examples: default blue, "Avvertimento", "Pericolo"). */
+export type SirioDialogTone = 'default' | 'warning' | 'danger';
+/**
+ * Footer of a dialog (kit `.sirio-dialog-footer`), with the action buttons:
+ * `<div wmSirioDialogFooter>...</div>`.
+ */
+export declare class SirioDialogFooter {
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDialogFooter, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioDialogFooter, "[wmSirioDialogFooter]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Closes the enclosing dialog when clicked (kit `data-sirio-dismiss="dialog"`):
+ * `<button wmSirioButton="secondary" wmSirioDialogClose>Annulla</button>`.
+ * With a value (`[wmSirioDialogClose]="true"`) the value is emitted by the dialog `(closed)`.
+ */
+export declare class SirioDialogClose {
+  /** Result reported by the dialog `(closed)` output. */
+  readonly result: import("@angular/core").InputSignal<unknown>;
+  private readonly dialog;
+  protected close(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDialogClose, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioDialogClose, "[wmSirioDialogClose]", never, {
+    "result": {
+      "alias": "wmSirioDialogClose";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Dialog of the Sirio web kit ("Dialog"): `.sirio-dialog` (backdrop) > `.sirio-dialog-wrapper`
+ * (size `sm` / `lg` / `xl`, `dialog-centered`) > `.sirio-dialog-content` with header
+ * (`h2.sirio-dialog-title` with the icon, close button `.sirio-btn-close`), body and footer.
+ *
+ * Behaviour of the kit script (SirioDialog) reproduced in Angular: `aria-modal`, focus moved into
+ * the dialog when it opens and back to the previously focused element when it closes, Esc and a
+ * click on the backdrop close it. In addition: `role="dialog"` (`alertdialog` with `alert`), focus kept
+ * inside the dialog (Tab / Shift+Tab), page scroll locked while open.
+ *
+ * With `drawer` it is the kit drawer (`.sirio-drawer`): a panel opening from the right. Inside a component
+ * opened by `SirioDialogService.open()` the dialog opens by itself and closes the `SirioDialogRef`.
+ *
+ * ```html
+ * <wm-sirio-dialog [(open)]="confirmOpen" title="Vuoi eliminare il tuo account?" tone="danger" alert
+ *               (closed)="onClosed($event)">
+ *   <p>L'operazione non è reversibile.</p>
+ *   <div wmSirioDialogFooter>
+ *     <button wmSirioButton="ghost" type="button" wmSirioDialogClose>Annulla</button>
+ *     <button wmSirioButton="danger" type="button" [wmSirioDialogClose]="true">Elimina</button>
+ *   </div>
+ * </wm-sirio-dialog>
+ * ```
+ */
+export declare class SirioDialog {
+  /** Visibility (two-way: `[(open)]`). */
+  readonly open: import("@angular/core").ModelSignal<boolean>;
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Accessible name when there is no title. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  /** Font Awesome icon of the title (kit: `fa-exclamation-circle`); null = no icon. */
+  readonly icon: import("@angular/core").InputSignal<string | null>;
+  /** Color of the icon: default (blue), warning (`sirio-text-warning`), danger (`sirio-text-danger`). */
+  readonly tone: import("@angular/core").InputSignal<SirioDialogTone>;
+  readonly size: import("@angular/core").InputSignal<SirioDialogSize>;
+  /** Vertically centered (kit `dialog-centered`). */
+  readonly centered: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Close button in the header (kit). */
+  readonly dismissible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  /** Esc and a click on the backdrop close the dialog (kit behaviour). */
+  readonly closeOnEscape: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly closeOnBackdrop: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `role="alertdialog"` for confirmations that interrupt the user (e.g. destructive actions). */
+  readonly alert: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Kit drawer: panel opening from the right (`.sirio-drawer`). */
+  readonly drawer: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Extra classes of the `.sirio-dialog` element (e.g. kit drawer / side panel classes). */
+  readonly panelClass: import("@angular/core").InputSignal<string>;
+  /**
+   * The panel is also shown in the page while closed (kit side filters: `d-lg-flex` on desktop):
+   * it is a dialog (`role`, focus trap) only when open.
+   */
+  readonly inline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emitted after the dialog opens. */
+  readonly opened: import("@angular/core").OutputEmitterRef<void>;
+  /** Emitted when the dialog closes, with the result of `wmSirioDialogClose` (undefined otherwise). */
+  readonly closed: import("@angular/core").OutputEmitterRef<unknown>;
+  protected readonly footer: import("@angular/core").Signal<SirioDialogFooter | undefined>;
+  private readonly dialogRef;
+  private readonly document;
+  private readonly injector;
+  /** Reference of a dialog opened from code, when this is its dialog (see SirioDialogService.open). */
+  private readonly openedRef;
+  private readonly baseId;
+  protected readonly dialogId: string;
+  protected readonly titleId: string;
+  protected readonly iconClasses: import("@angular/core").Signal<string>;
+  /** Element focused before opening (focus returns there on close). */
+  private returnFocus;
+  private pendingResult;
+  private backdropPressed;
+  /** The opening steps ran (focus saved, scroll locked) and the closing ones did not yet. */
+  private shown;
+  constructor();
+  /** Opens the dialog (kit SirioDialog.show()). */
+  show(): void;
+  /** Closes the dialog (kit SirioDialog.hide()); `result` is emitted by `(closed)`. */
+  close(result?: unknown): void;
+  toggle(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  /** Backdrop click: the press and the release must both happen on the backdrop. */
+  protected onBackdropMousedown(event: MouseEvent): void;
+  protected onBackdropClick(event: MouseEvent): void;
+  private isBackdrop;
+  private onOpen;
+  private onClose;
+  private trapFocus;
+  private lockScroll;
+  private unlockScroll;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SirioDialog, "wm-sirio-dialog", never, {
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "centered": {
+      "alias": "centered";
+      "required": false;
+      "isSignal": true;
+    };
+    "dismissible": {
+      "alias": "dismissible";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeOnEscape": {
+      "alias": "closeOnEscape";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeOnBackdrop": {
+      "alias": "closeOnBackdrop";
+      "required": false;
+      "isSignal": true;
+    };
+    "alert": {
+      "alias": "alert";
+      "required": false;
+      "isSignal": true;
+    };
+    "drawer": {
+      "alias": "drawer";
+      "required": false;
+      "isSignal": true;
+    };
+    "panelClass": {
+      "alias": "panelClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "inline": {
+      "alias": "inline";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "open": "openChange";
+    "opened": "opened";
+    "closed": "closed";
+  }, ["footer"], ["*", "[wmSirioDialogFooter]"], true, never>;
+}
+/** Dialog components, for `imports: [SIRIO_DIALOG]`. */
+export declare const SIRIO_DIALOG: readonly [typeof SirioDialog, typeof SirioDialogFooter, typeof SirioDialogClose];
+/**
+ * TanStack Table features of the grid: filtering (with faceted values), grouping with
+ * aggregation, sorting, expanding (detail rows, tree data, groups), pagination, column ordering
+ * and sizing.
+ */
+declare const GRID_FEATURES: {
+  columnFilteringFeature: import("@tanstack/table-core").TableFeature;
+  filteredRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  columnFacetingFeature: import("@tanstack/table-core").TableFeature;
+  facetedRowModel: (table: import("@tanstack/table-core").Table<any, any>, columnId: string) => () => import("@tanstack/table-core").RowModel<any, any>;
+  facetedUniqueValues: (table: import("@tanstack/table-core").Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+  groupedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  rowAggregationFeature: import("@tanstack/table-core").TableFeature;
+  aggregationFns: {
+    sum: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    mean: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    min: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    max: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    count: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+  };
+  rowSortingFeature: import("@tanstack/table-core").TableFeature;
+  sortedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  rowExpandingFeature: import("@tanstack/table-core").TableFeature;
+  expandedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  rowPaginationFeature: import("@tanstack/table-core").TableFeature;
+  paginatedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  columnOrderingFeature: import("@tanstack/table-core").TableFeature;
+  columnSizingFeature: import("@tanstack/table-core").TableFeature;
+};
+type GridFeatures = typeof GRID_FEATURES;
+/** A row of the TanStack row model (data row, sub-row or group row). */
+export type SirioGridRow<T extends object = any> = Row<GridFeatures, T>;
+/** Drop position while dragging a header. */
+interface DropTarget {
+  id: string;
+  side: 'before' | 'after';
+}
+/** Edit dialog of a `[formArray]` grid: the copy being edited and the row it comes from. */
+interface EditSession<T extends object> {
+  context: SirioGridEditorContext<T>;
+  /** Group of the form array (null for a new row). */
+  original: FormGroup | null;
+}
+/**
+ * A cell of the grouped headers: a group header (over `colspan` adjacent columns of the same block)
+ * or a column header (with `rowspan` below a shorter group path).
+ */
+type HeaderCell<T extends object> = {
+  kind: 'group';
+  track: string;
+  label: string;
+  colspan: number;
+  /** First and last column ids, for the fixed position. */
+  pin: readonly [string, string];
+} | {
+  kind: 'column';
+  track: string;
+  column: SirioGridColumn<T>;
+  rowspan: number;
+};
+/**
+ * Cell of a fixed column (header and body): sticky position at the offset measured by the grid,
+ * with the separator / scroll marker on the edge of the fixed block. A group header passes the
+ * first and last column ids it spans.
+ * @internal
+ */
+export declare class SirioGridPinCell {
+  readonly key: import("@angular/core").InputSignal<string | readonly [string, string]>;
+  private readonly grid;
+  private readonly first;
+  private readonly last;
+  /** Only single cells are measured (a group header spans more columns). */
+  protected readonly measureKey: import("@angular/core").Signal<string | null>;
+  protected readonly side: import("@angular/core").Signal<SirioGridFixed | null>;
+  /** Left block: offset of the first column; right block: offset of the last one (see PIN_OVERHANG). */
+  protected readonly offset: import("@angular/core").Signal<number>;
+  protected readonly edge: import("@angular/core").Signal<SirioGridFixed | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioGridPinCell, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioGridPinCell, "[wmSirioGridPin]", never, {
+    "key": {
+      "alias": "wmSirioGridPin";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Data grid based on the Sirio web kit table ("Tabelle"): `table.sirio-table` with the kit
+ * variants (`sirio-table-dark`, `sirio-table-light`), densities (`sirio-table-xs/sm/lg`), sortable
+ * headers (`.sirio-sorting`, `-asc`, `-desc`), selection checkboxes (`.sirio-table-check`), the
+ * responsive container (`.sirio-table-responsive` with the `overflow-start/end` scroll markers),
+ * fixed header / first column / last column and the card layout for small screens
+ * (`.sirio-table-card` with `data-label`), followed by `wm-sirio-pagination`.
+ *
+ * Data processing is done by TanStack Table (`@tanstack/angular-table`, `injectTable`): column
+ * filters (with the values present in the column for the select filters), sorting on one or more
+ * columns, grouping with aggregations, expanding (detail panel, tree data, groups), pagination,
+ * column order and widths. With a server data source filtering, sorting and pagination run in
+ * manual mode (the page is shown as received) and grouping is not available.
+ *
+ * Columns are declared with `wm-sirio-grid-column` (optional `wmSirioGridCell` / `wmSirioGridHeader`
+ * templates); `wmSirioGridDetail` adds expandable detail rows.
+ *
+ * ```html
+ * <wm-sirio-data-grid [data]="pratiche" rowId="id" selection="multiple" [(selected)]="scelte">
+ *   <wm-sirio-grid-column field="numero" header="Numero" sortable />
+ *   <wm-sirio-grid-column field="importo" header="Importo" align="end" [format]="euro" sortable />
+ * </wm-sirio-data-grid>
+ * ```
+ */
+export declare class SirioDataGrid<T extends object = any> {
+  private readonly document;
+  private readonly injector;
+  /** Rows in memory: filtered, sorted, grouped and paged by the grid. Ignored with `dataSource`. */
+  readonly data: import("@angular/core").InputSignal<readonly T[] | null>;
+  /** Server side data source (see `SirioGridDataSource`); takes precedence over `data`. */
+  readonly dataSource: import("@angular/core").InputSignal<SirioGridDataSource<T> | null>;
+  /** Identity of a row (property name or function) for tracking and selection; null = the object. */
+  readonly rowId: import("@angular/core").InputSignal<SirioGridRowId<T>>;
+  /** Sub-rows of a row (tree data): property name or function; the rows get an expand button. */
+  readonly subRows: import("@angular/core").InputSignal<SirioGridSubRows<T> | null>;
+  /** External loading flag (e.g. while the page fetches `data`); the data source sets its own. */
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Rows from a form array, one form group per row (instead of `data`; ignored with `dataSource`).
+   * The grid shows `getRawValue()` of each group and follows the changes of the array; rows are
+   * edited in a dialog (`wmSirioGridEditor`), added (`addable`) and removed (`deletable`).
+   */
+  readonly formArray: import("@angular/core").InputSignal<FormArray<any> | null>;
+  /**
+   * Form group of a row with its validators: for a new row (null or the initial values) and for the
+   * copy edited in the dialog. Without it existing rows are edited on a generic copy of their group
+   * (same controls, values and validators) and new rows cannot be added.
+   */
+  readonly rowFactory: import("@angular/core").InputSignal<SirioGridRowFactory<T> | null>;
+  /** "Aggiungi" button: a new row edited in the dialog, added at the end (needs `rowFactory`). */
+  readonly addable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** "Elimina" button on the rows (and "Elimina selezionati" with multiple selection). */
+  readonly deletable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Rows that can be changed (the others open the dialog read-only); null = every row. */
+  readonly rowEditable: import("@angular/core").InputSignal<((row: T) => boolean) | null>;
+  /** Rows that can be removed; null = every row. */
+  readonly rowDeletable: import("@angular/core").InputSignal<((row: T) => boolean) | null>;
+  /** A double click on a row opens the dialog. */
+  readonly editOnDoubleClick: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Confirmation dialog before removing rows. */
+  readonly confirmDelete: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Check before applying a save (e.g. a call to the server): see `SirioGridChangeHandler`. */
+  readonly saveHandler: import("@angular/core").InputSignal<SirioGridChangeHandler<SirioGridRowSaveEvent<T>> | null>;
+  /** Check before removing a row: see `SirioGridChangeHandler`. */
+  readonly deleteHandler: import("@angular/core").InputSignal<SirioGridChangeHandler<SirioGridRowDeleteEvent<T>> | null>;
+  /** Size of the edit dialog (kit `sirio-dialog-sm/lg/xl`). */
+  readonly editorSize: import("@angular/core").InputSignal<SirioDialogSize>;
+  /** Messages of the form array errors under the grid (over the global and the grid defaults). */
+  readonly errorMessages: import("@angular/core").InputSignal<SirioErrorMessages | null>;
+  /** Sort criteria in priority order (two-way: `[(sort)]`); empty = original order. */
+  readonly sort: import("@angular/core").ModelSignal<SirioGridSort[]>;
+  /** `multiple`: Shift+click (or Shift+Enter) on a header adds it to the sort. */
+  readonly sortMode: import("@angular/core").InputSignal<SirioGridSortMode>;
+  /** Shows `wm-sirio-pagination` and pages the rows; false shows every row. */
+  readonly pageable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Current page, 1-based (two-way: `[(page)]`). */
+  readonly page: import("@angular/core").ModelSignal<number>;
+  /** Rows per page (two-way: `[(pageSize)]`); with groups or tree data the top level rows count. */
+  readonly pageSize: import("@angular/core").ModelSignal<number>;
+  readonly pageSizeOptions: import("@angular/core").InputSignal<number[]>;
+  /**
+   * Layout of the pagination (`wm-sirio-pagination variant`): `full` (elements per page, range,
+   * page select, previous/next) or `numbers` (page numbers with ellipsis).
+   */
+  readonly paginationVariant: import("@angular/core").InputSignal<SirioPaginationVariant>;
+  /** Pages shown on each side of the current one with `paginationVariant="numbers"`. */
+  readonly paginationSiblings: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** "Elementi per pagina" block (select + range) of the `full` pagination. */
+  readonly paginationShowItems: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly selection: import("@angular/core").InputSignal<SirioGridSelection>;
+  /** Selected rows (two-way: `[(selected)]`), compared by `rowId`. */
+  readonly selected: import("@angular/core").ModelSignal<readonly T[]>;
+  /** Column filters by filter key (two-way: `[(filters)]`), see `SirioGridFilterType`. */
+  readonly filters: import("@angular/core").ModelSignal<SirioGridFilters>;
+  /** Delay (ms) before a typed text filter is applied; the other filters apply at once. */
+  readonly filterDebounce: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Filters with operators on every column with a filter (a "Condizione" choice: contiene, uguale
+   * a, maggiore di, compreso tra, vuoto, ...): the filter values become `SirioGridFilterCondition`.
+   * A column can override it with its own `filterOperators`.
+   */
+  readonly filterOperators: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Active filters as kit chips above the table (each one removable). */
+  readonly showFilterChips: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Filter buttons of the headers: `always` visible (default), `hover` (as ag-grid: shown on mouse
+   * over, with the keyboard focus or when the filter is active; the space stays reserved) or `none`
+   * (no filter controls in the grid, card panel included: the filters are set from code, e.g.
+   * `[(filters)]` or `setFilter`, as the ag-grid columns with a filter and no floating filter).
+   */
+  readonly filterButton: import("@angular/core").InputSignal<"always" | "none" | "hover">;
+  /**
+   * Row of filters under the column headers (as the floating filters of ag-grid): a field for the
+   * simple condition of each filterable column, the filter button for the others. The filter chips
+   * are not shown; in the card layout the "Filtri" panel stays.
+   */
+  readonly filterRow: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Keys of the columns the rows are grouped by, in order (two-way: `[(grouping)]`). */
+  readonly grouping: import("@angular/core").ModelSignal<string[]>;
+  /** Expanded rows (two-way: `[(expanded)]`): detail rows, tree rows and groups. */
+  readonly expanded: import("@angular/core").ModelSignal<SirioGridExpanded>;
+  /** With `wmSirioGridDetail`: which rows have a detail (default every data row). */
+  readonly rowExpandable: import("@angular/core").InputSignal<((row: T) => boolean) | null>;
+  /**
+   * Row number column at the start (after selection and expand columns): continuous across pages,
+   * in the current filter and sort order; group rows have no number, tree rows are numbered by
+   * level (1, 1.1, 1.2). It is the row header (`role="rowheader"`) for screen readers.
+   */
+  readonly rowNumbers: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** A click on the row (outside links, buttons and fields) also selects it. */
+  readonly selectOnRowClick: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Column of the selection checkboxes / radios (with "select all" in multiple mode). False: no
+   * column, the rows are selected with a click (multiple: each click toggles the row, no Ctrl or
+   * Shift needed) or with Space / Enter on the focused row.
+   */
+  readonly selectionColumn: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Keyboard navigation as ag-grid (ARIA grid): the grid is one tab stop (entered on the first
+   * column header, then the last cell visited), the arrows move between
+   * headers and cells (Home / End: start and end of the row, Ctrl+Home / Ctrl+End: first and last
+   * cell), Tab leaves the grid. A cell with buttons or fields passes the focus to them (e.g. the
+   * actions, one stop each). Space / Enter on a cell selects its row when the rows are selected
+   * without the checkbox column. The fields of the filter row keep their own tab stops.
+   * False: a plain table, only the interactive headers and the controls are tab stops.
+   */
+  readonly keyboardNavigation: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Navigation active (not in the card layout of small screens). */
+  protected readonly navigation: import("@angular/core").Signal<boolean>;
+  /**
+   * Role of the cells of the filter row: data cells, not column headers (an empty header was announced
+   * as a header without name, and the body cells must keep the titles of the first row as headers).
+   */
+  protected readonly filterCellRole: import("@angular/core").Signal<"cell" | "gridcell">;
+  /** ARIA role of the table with the navigation: grid, treegrid with tree or grouped rows (aria-level). */
+  protected readonly gridRole: import("@angular/core").Signal<"treegrid" | "grid" | null>;
+  /**
+   * Which rows can be selected (as `isRowSelectable` of ag-grid); null = every row. The other rows
+   * have a disabled box (hidden with `hideUnselectable`), are skipped by "select all" and by the
+   * click / keyboard selection. Rows already in `selected` stay selected.
+   */
+  readonly rowSelectable: import("@angular/core").InputSignal<((row: T) => boolean) | null>;
+  /** The selection box of the rows that cannot be selected is hidden instead of disabled. */
+  readonly hideUnselectable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Rows taken by "seleziona tutto" (multiple selection): `page` (default) the current page,
+   * `filtered` every row that passes the filters over all the pages (ag-grid `selectAll: 'filtered'`),
+   * `all` every row. With a server data source it is always the loaded page.
+   */
+  readonly selectAll: import("@angular/core").InputSignal<SirioGridSelectAll>;
+  /**
+   * Classes of the data rows: text, list or object `{ classe: condizione }`, or a function of the row
+   * and of its index in the page (e.g. `(row) => ({ 'riga-scaduta': row.scaduta })`).
+   */
+  readonly rowClass: import("@angular/core").InputSignal<SirioGridRowClass<T>>;
+  /**
+   * Inline styles of the data rows: CSS text or object, or a function of the row and of its index.
+   * A background color is applied to the cells (over the stripes and the fixed cells; the
+   * selection still shows).
+   */
+  readonly rowStyle: import("@angular/core").InputSignal<SirioGridRowStyle<T>>;
+  /** The column widths can be changed by dragging the right edge of the headers (or with the keyboard). */
+  readonly resizable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The columns can be moved by dragging the headers (or with Alt+arrows on a header). */
+  readonly reorderable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Widths in pixels by column key (two-way: `[(columnWidths)]`); empty = automatic layout. */
+  readonly columnWidths: import("@angular/core").ModelSignal<Record<string, number>>;
+  /** Column keys in display order (two-way: `[(columnOrder)]`); empty = declaration order. */
+  readonly columnOrder: import("@angular/core").ModelSignal<string[]>;
+  readonly variant: import("@angular/core").InputSignal<SirioGridVariant>;
+  readonly size: import("@angular/core").InputSignal<SirioGridSize>;
+  /** Horizontal scroll container of the kit with the scroll markers. */
+  readonly responsive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Header fixed while the rows scroll (kit `sirio-table-th-fixed`). Without `height` /
+   * `maxHeight` the rows area takes the kit height (450px).
+   */
+  readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * First data column fixed during the horizontal scroll (with the selection, expand and row number
+   * columns before it), like the kit `sirio-table-column-fixed-first`. Shortcut of `fixed="left"`
+   * on the first column; ignored when a column is already fixed at the left.
+   */
+  readonly fixedFirstColumn: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Last column (e.g. actions) fixed during the horizontal scroll, like the kit
+   * `sirio-table-action-fixed`. Shortcut of `fixed="right"` on the last column; ignored when a
+   * column is already fixed at the right.
+   */
+  readonly fixedLastColumn: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Height of the grid (CSS, as `style.height`: `400px`, `50vh`); null (default) = the height of
+   * the content, every row shown. The rows scroll inside, the header stays visible; toolbar,
+   * filter chips and pagination stay out of the scroll area.
+   */
+  readonly height: import("@angular/core").InputSignal<string | null>;
+  /** Minimum height of the grid (CSS): with fewer rows the rows area grows, the pagination stays at the bottom. */
+  readonly minHeight: import("@angular/core").InputSignal<string | null>;
+  /** Maximum height of the grid (CSS): the grid follows its content up to this height, then the rows scroll. */
+  readonly maxHeight: import("@angular/core").InputSignal<string | null>;
+  /** A height limit is set: the rows area fills the grid and scrolls. */
+  protected readonly sized: import("@angular/core").Signal<boolean>;
+  /**
+   * Card layout on small screens (kit `sirio-table-card`: up to 768px wide every row becomes a
+   * card and each cell shows its header as label).
+   */
+  readonly cardOnMobile: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Caption of the table (accessible name). */
+  readonly caption: import("@angular/core").InputSignal<string>;
+  /** Shows the caption; otherwise it is visually hidden (still read by screen readers). */
+  readonly captionVisible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly emptyText: import("@angular/core").InputSignal<string>;
+  readonly loadingText: import("@angular/core").InputSignal<string>;
+  /** Message of a failed server data source (with the "Riprova" button); empty = no message. */
+  readonly loadErrorText: import("@angular/core").InputSignal<string>;
+  readonly retryLabel: import("@angular/core").InputSignal<string>;
+  /** Read before an open server total (no `total` in the response): "oltre 30 risultati". */
+  readonly moreLabel: import("@angular/core").InputSignal<string>;
+  readonly resultsLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible label of the "seleziona tutto" checkbox; null = the text of `selectAll`. */
+  readonly selectAllLabel: import("@angular/core").InputSignal<string | null>;
+  /** Screen reader hint of the rows selected without the checkbox column (`selectionColumn` false). */
+  readonly selectRowHint: import("@angular/core").InputSignal<string>;
+  /** Accessible label of the selection box of a row. */
+  /**
+   * Control of the rows with single selection: `radio` (default) or `checkbox` (as ag-grid; a checked
+   * box is unchecked by selecting another row or by clicking it again).
+   */
+  readonly singleSelectionControl: import("@angular/core").InputSignal<"radio" | "checkbox">;
+  /** Radio buttons in the selection column (single selection with `singleSelectionControl="radio"`). */
+  protected readonly singleRadio: import("@angular/core").Signal<boolean>;
+  /** Header of the selection column with single selection (screen readers only). */
+  readonly selectionHeaderLabel: import("@angular/core").InputSignal<string>;
+  readonly selectRowLabel: import("@angular/core").InputSignal<(row: T, index: number) => string>;
+  readonly sortAscendingLabel: import("@angular/core").InputSignal<string>;
+  readonly sortDescendingLabel: import("@angular/core").InputSignal<string>;
+  /** Hint of the sortable headers with `sortMode="multiple"`. */
+  readonly multiSortHint: import("@angular/core").InputSignal<string>;
+  readonly paginationAriaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Accessible name of the paginator: `paginationAriaLabel` followed by the `caption`, so that the
+   * paginators of more grids in a page are told apart ("Paginazione della tabella Prodotti").
+   */
+  protected readonly paginationName: import("@angular/core").Signal<string>;
+  /** Prefix of the filter button and of the popover title: "Filtra per <header>". */
+  readonly filterLabel: import("@angular/core").InputSignal<string>;
+  readonly filterFromLabel: import("@angular/core").InputSignal<string>;
+  readonly filterToLabel: import("@angular/core").InputSignal<string>;
+  /** Empty choice of the select filters. */
+  readonly filterAllLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Prefix of the filter button in the filter row ("Altre condizioni per <header>"): the field of the
+   * cell is already "Filtra per <header>".
+   */
+  readonly filterMoreLabel: import("@angular/core").InputSignal<string>;
+  readonly filterYesLabel: import("@angular/core").InputSignal<string>;
+  readonly filterNoLabel: import("@angular/core").InputSignal<string>;
+  /** Added to the label of the filter button when its filter is active. */
+  readonly filterActiveLabel: import("@angular/core").InputSignal<string>;
+  readonly clearFilterLabel: import("@angular/core").InputSignal<string>;
+  readonly clearFiltersLabel: import("@angular/core").InputSignal<string>;
+  /** Label of the operator choice of the filters with operators. */
+  readonly filterConditionLabel: import("@angular/core").InputSignal<string>;
+  /** Label of the value of a filter with operators. */
+  readonly filterValueLabel: import("@angular/core").InputSignal<string>;
+  /** Joins the bounds of `between` in the filter chips ("compreso tra 10 e 20"). */
+  readonly filterAndLabel: import("@angular/core").InputSignal<string>;
+  /** Labels of the filter operators, over the Italian defaults (e.g. `{ contains: 'Contains' }`). */
+  readonly filterOperatorLabels: import("@angular/core").InputSignal<Partial<Record<SirioGridFilterOperator, string>>>;
+  /** Title of the filter panel of the card layout and sr-only title of the chips. */
+  readonly filtersLabel: import("@angular/core").InputSignal<string>;
+  /** Visible header of the row number column. */
+  readonly rowNumberHeader: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the row number column. */
+  readonly rowNumberLabel: import("@angular/core").InputSignal<string>;
+  readonly groupByLabel: import("@angular/core").InputSignal<string>;
+  readonly expandAllLabel: import("@angular/core").InputSignal<string>;
+  readonly collapseAllLabel: import("@angular/core").InputSignal<string>;
+  /** Name of a row in the labels of its expand button ("Espandi <name>"). */
+  readonly rowName: import("@angular/core").InputSignal<(row: T, index: number) => string>;
+  readonly expandRowLabel: import("@angular/core").InputSignal<string>;
+  readonly collapseRowLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible label of the resize handle: "<label> <header>". */
+  readonly resizeColumnLabel: import("@angular/core").InputSignal<string>;
+  /** Hint of the headers of a reorderable grid. */
+  readonly reorderHint: import("@angular/core").InputSignal<string>;
+  /** Hint of a resizable header (keyboard of ag-grid: Alt+arrows). */
+  readonly resizeHint: import("@angular/core").InputSignal<string>;
+  /** Hint of a header with a filter button (Ctrl+Enter opens it, as ag-grid). */
+  readonly filterHint: import("@angular/core").InputSignal<string>;
+  readonly resetColumnsLabel: import("@angular/core").InputSignal<string>;
+  /** Announcement of a moved column. */
+  readonly columnMovedLabel: import("@angular/core").InputSignal<(header: string, position: number, total: number) => string>;
+  /** Texts of the `[formArray]` editing. */
+  readonly actionsHeader: import("@angular/core").InputSignal<string>;
+  readonly addLabel: import("@angular/core").InputSignal<string>;
+  readonly editLabel: import("@angular/core").InputSignal<string>;
+  readonly viewLabel: import("@angular/core").InputSignal<string>;
+  readonly deleteLabel: import("@angular/core").InputSignal<string>;
+  readonly deleteSelectedLabel: import("@angular/core").InputSignal<string>;
+  readonly newRowTitle: import("@angular/core").InputSignal<string>;
+  readonly editRowTitle: import("@angular/core").InputSignal<string>;
+  readonly viewRowTitle: import("@angular/core").InputSignal<string>;
+  readonly saveLabel: import("@angular/core").InputSignal<string>;
+  readonly cancelLabel: import("@angular/core").InputSignal<string>;
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  readonly deleteConfirmTitle: import("@angular/core").InputSignal<string>;
+  readonly deleteSelectedConfirmTitle: import("@angular/core").InputSignal<string>;
+  readonly deleteConfirmMessage: import("@angular/core").InputSignal<string>;
+  /** Hint of a row with errors (icon in the actions column). */
+  readonly invalidRowLabel: import("@angular/core").InputSignal<string>;
+  readonly saveErrorTitle: import("@angular/core").InputSignal<string>;
+  /** Text of a failed save when the error has no message of its own. */
+  readonly saveErrorText: import("@angular/core").InputSignal<string>;
+  /** Click on a data row, outside links, buttons and fields. */
+  readonly rowClick: import("@angular/core").OutputEmitterRef<SirioGridRowEvent<T>>;
+  /** Error of the data source (the grid shows no rows). */
+  readonly loadError: import("@angular/core").OutputEmitterRef<unknown>;
+  /** The state chosen by the user changed (sort, filters, page, columns, grouping, expansion, selection). */
+  readonly stateChange: import("@angular/core").OutputEmitterRef<SirioGridState>;
+  /** A row of the form array was saved from the dialog (changed or added). */
+  readonly rowSave: import("@angular/core").OutputEmitterRef<SirioGridRowSaveEvent<T>>;
+  /** A row was removed from the form array. */
+  readonly rowDelete: import("@angular/core").OutputEmitterRef<SirioGridRowDeleteEvent<T>>;
+  /** @internal */
+  readonly columns: import("@angular/core").Signal<readonly SirioGridColumn<any>[]>;
+  protected readonly emptyTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  protected readonly detailTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  protected readonly errorTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  protected readonly editorTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+  private readonly scroller;
+  private readonly tableEl;
+  protected readonly baseId: string;
+  /** Numbers (counts, filter values) and dates (filter chips) in the format of `LOCALE_ID`. */
+  private readonly locale;
+  private readonly numberFormat;
+  private readonly dateFormat;
+  /** Default sort of the columns without `compare`: text collation of `LOCALE_ID`. */
+  private readonly defaultCompare;
+  /** Widths (px) of the service columns in the resized layout (colgroup). */
+  protected readonly toolColumnWidth = 48;
+  protected readonly rowNumberWidth = 64;
+  /** Width of the actions column: its buttons, plus the error icon when a row has errors. */
+  protected readonly actionsWidth: import("@angular/core").Signal<number>;
+  private readonly serverResult;
+  /**
+   * Total of the server rows: from the response, or found from the pages (open while every page
+   * received is full). `key` is the query without the page: a new sort, filter or page size
+   * starts again.
+   */
+  private readonly serverTotal;
+  /** Error of the last request of the data source (null after a successful one). */
+  protected readonly serverError: import("@angular/core").WritableSignal<{
+    error: unknown;
+  } | null>;
+  /** Context of the error template. */
+  protected readonly errorContext: import("@angular/core").Signal<{
+    $implicit: unknown;
+    error: unknown;
+    retry: () => void;
+  } | null>;
+  private readonly serverLoading;
+  private readonly reloadTick;
+  private subscription;
+  /** The next filter change is applied without the debounce (not a typed text). */
+  private immediateFilter;
+  private request;
+  protected readonly overflowStart: import("@angular/core").WritableSignal<boolean>;
+  protected readonly overflowEnd: import("@angular/core").WritableSignal<boolean>;
+  /** Viewport within the kit card breakpoint (768px). */
+  private readonly mobile;
+  /** The card layout is active now (scroll container, fixed and resized columns are turned off). */
+  protected readonly cardMode: import("@angular/core").Signal<boolean>;
+  readonly isLoading: import("@angular/core").Signal<boolean>;
+  protected readonly server: import("@angular/core").Signal<boolean>;
+  /** Filters in use (the typed text ones after `filterDebounce`). */
+  private readonly appliedFilters;
+  /** Filter panel of the card layout open. */
+  protected readonly filtersOpen: import("@angular/core").WritableSignal<boolean>;
+  /** Announcement of the last column move (sr-only live region). */
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  /** Header being dragged and drop position. */
+  protected readonly dragId: import("@angular/core").WritableSignal<string | null>;
+  protected readonly dropTarget: import("@angular/core").WritableSignal<DropTarget | null>;
+  /** Width of each column measured when the resizing starts (reset target). */
+  private initialWidths;
+  /**
+   * Id of a column in the TanStack table: its key, or its position when it has none. A key already
+   * used by a previous column (the same field shown twice, e.g. with another format) gets a suffix.
+   */
+  columnId(column: SirioGridColumn<T>): string;
+  private readonly columnIds;
+  /**
+   * Key of a column in `filters` (and in the query of a server source): its `filterKey`, otherwise
+   * its id, unique also for columns on the same field (`data`, `data~2`): a date shown as date and
+   * as time must not share the filter of the other column.
+   */
+  filterIdOf(column: SirioGridColumn<T>): string;
+  private readonly columnsById;
+  /**
+   * TanStack Table definitions of the columns. The column inputs that change the processing are
+   * read here, so the definitions (and the row models) are rebuilt when they change.
+   */
+  private readonly columnDefs;
+  /** Columns in the TanStack column order, hidden ones excluded. */
+  private readonly orderedColumns;
+  /**
+   * Fixed side of the columns: their `fixed` input, plus `fixedFirstColumn` / `fixedLastColumn`.
+   * Columns are fixed only in the kit scroll container (not in the card layout).
+   */
+  private readonly fixedSides;
+  /** Group levels of the headers (0 = no grouped headers). */
+  protected readonly headerDepth: import("@angular/core").Signal<number>;
+  /** Rowspan of the service headers (selection, expand, row number) over every header row. */
+  protected readonly headerRowspan: import("@angular/core").Signal<number | null>;
+  /**
+   * Header rows: one per group level, then the column headers. Adjacent columns of the same fixed
+   * block with the same groups share a group cell; a column with fewer group levels has its header
+   * in the row after its last group, spanning the rows below.
+   */
+  protected readonly headerRows: import("@angular/core").Signal<HeaderCell<T>[][]>;
+  /** Sticky top (px) of each header row with the fixed header: height of the rows above. */
+  private readonly headerTops;
+  /** Height of the header rows: the cells focused with Tab are scrolled out from under the fixed header. */
+  protected readonly headerHeight: import("@angular/core").WritableSignal<number>;
+  private headerObserver;
+  protected headerTop(row: number): number | null;
+  private measureHeaderRows;
+  /** Fixed side of a column (null = it scrolls). */
+  protected fixedOf(column: SirioGridColumn<T>): SirioGridFixed | null;
+  /** Columns in display order: the left fixed ones, the scrolling ones, the right fixed ones. */
+  protected readonly visibleColumns: import("@angular/core").Signal<SirioGridColumn<T>[]>;
+  /**
+   * Keys of the fixed cells by side, in display order. The service columns (selection, expand,
+   * row number) are fixed with the left fixed columns, which follow them.
+   */
+  private readonly pinKeys;
+  protected readonly hasPinLeft: import("@angular/core").Signal<boolean>;
+  protected readonly hasPinRight: import("@angular/core").Signal<boolean>;
+  /** Sticky offset (px) of each fixed cell, measured on the headers. @internal */
+  readonly pinOffsets: import("@angular/core").WritableSignal<Record<string, number>>;
+  private pinObserver;
+  /** Side of a fixed cell (column id or service key). @internal */
+  pinSideOf(key: string): SirioGridFixed | null;
+  /** Edge of the fixed block where the cell is (last left / first right cell). @internal */
+  pinEdgeOf(key: string): SirioGridFixed | null;
+  /** Offsets of the fixed cells: sum of the widths of the fixed headers before them on their side. */
+  private measurePins;
+  /** Widths of the fixed blocks: the kit scroll markers of the container are drawn at their inner edge. */
+  protected readonly pinBlockWidths: import("@angular/core").WritableSignal<{
+    left: number;
+    right: number;
+  }>;
+  protected readonly filterColumns: import("@angular/core").Signal<SirioGridColumn<T>[]>;
+  /** Filter row shown (`filterRow`, a filterable column, not in the card layout). */
+  protected readonly filterRowActive: import("@angular/core").Signal<boolean>;
+  protected readonly groupableColumns: import("@angular/core").Signal<SirioGridColumn<any>[]>;
+  protected readonly groupOptions: import("@angular/core").Signal<SirioOption<string>[]>;
+  /** Grouping in use (client side only, groupable columns only). */
+  protected readonly activeGrouping: import("@angular/core").Signal<string[]>;
+  protected readonly treeMode: import("@angular/core").Signal<boolean>;
+  protected readonly hasDetail: import("@angular/core").Signal<boolean>;
+  /** Column of the selection checkboxes / radios shown. */
+  protected readonly checkColumn: import("@angular/core").Signal<boolean>;
+  /** Rows selected with a click: `selectOnRowClick`, or no checkbox column. */
+  protected readonly clickSelect: import("@angular/core").Signal<boolean>;
+  /** Rows focusable and selected with Space / Enter (no checkbox to reach with the keyboard). */
+  protected readonly keySelect: import("@angular/core").Signal<boolean>;
+  protected readonly colCount: import("@angular/core").Signal<number>;
+  /** Inner width of the scroll container (px), for the flex columns. */
+  private readonly containerWidth;
+  /** Content width of the columns without `width`, measured in the automatic layout. */
+  private readonly naturalWidths;
+  /** Columns sized by `flex` now (a resized column keeps its width). */
+  private readonly flexColumns;
+  /** Width of a column that is not flex: resized, declared (`width` in px) or content width. */
+  private fixedWidthOf;
+  /** Width of the service columns (selection, expand, row number). */
+  private readonly toolsWidth;
+  /**
+   * Widths of the flex columns: the free width (container - service columns - other columns)
+   * shared by `flex`, within min / max width; null while a width is still to be measured.
+   */
+  private readonly flexWidths;
+  /** Fixed layout with the widths of `columnWidths` (after a resize) or of the flex columns. */
+  protected readonly fixedLayout: import("@angular/core").Signal<boolean>;
+  /** Content widths of the columns without a width, while the automatic layout is shown. */
+  private measureNaturalWidths;
+  protected readonly tableWidth: import("@angular/core").Signal<number | null>;
+  protected readonly columnsCustomized: import("@angular/core").Signal<boolean>;
+  protected readonly booleanOptions: import("@angular/core").Signal<SirioOption<unknown>[]>;
+  /** Active filters as chips: "<header>: <value>". */
+  protected readonly filterChips: import("@angular/core").Signal<SirioFilterChip[]>;
+  /** Sort criteria as TanStack sorting state (criteria of unknown columns are dropped). */
+  private readonly sortingState;
+  /** Applied filters as TanStack column filters state. */
+  private readonly columnFiltersState;
+  /**
+   * TanStack Table instance: filtering, grouping, sorting, expanding and pagination of `data`
+   * (client side), or the page of the data source as it is (`manual*`, server side). Exposed for
+   * advanced uses (e.g. `table.getFilteredRowModel()`); the grid owns its state.
+   */
+  readonly table: import("@tanstack/angular-table").AngularTable<{
+    columnFilteringFeature: import("@tanstack/table-core").TableFeature;
+    filteredRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    columnFacetingFeature: import("@tanstack/table-core").TableFeature;
+    facetedRowModel: (table: import("@tanstack/table-core").Table<any, any>, columnId: string) => () => import("@tanstack/table-core").RowModel<any, any>;
+    facetedUniqueValues: (table: import("@tanstack/table-core").Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+    groupedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    rowAggregationFeature: import("@tanstack/table-core").TableFeature;
+    aggregationFns: {
+      sum: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+      mean: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+      min: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+      max: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+      count: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    };
+    rowSortingFeature: import("@tanstack/table-core").TableFeature;
+    sortedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    rowExpandingFeature: import("@tanstack/table-core").TableFeature;
+    expandedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    rowPaginationFeature: import("@tanstack/table-core").TableFeature;
+    paginatedRowModel: (table: import("@tanstack/table-core").Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+    columnOrderingFeature: import("@tanstack/table-core").TableFeature;
+    columnSizingFeature: import("@tanstack/table-core").TableFeature;
+  }, T>;
+  /** Total number of top level rows (groups, tree roots or rows): the pagination total. */
+  readonly total: import("@angular/core").Signal<number>;
+  /** Number of rows that pass the filters (not the groups). */
+  readonly resultCount: import("@angular/core").Signal<number>;
+  /** The server did not give the total and the last page is not reached yet: more rows exist. */
+  readonly totalOpen: import("@angular/core").Signal<boolean>;
+  readonly pageCount: import("@angular/core").Signal<number>;
+  /** Rows rendered: rows of the page with the expanded sub-rows and groups. */
+  protected readonly renderedRows: import("@angular/core").Signal<SirioGridRow<T>[]>;
+  /**
+   * Row numbers by row id: data rows counted in the current filter / group / sort order over every
+   * page (server side from the query offset); sub-rows of tree data numbered within their parent.
+   */
+  private readonly rowNumberMap;
+  /** Number of a rendered row (`rowNumbers`). */
+  protected rowNumberOf(row: SirioGridRow<T>): string;
+  /** Data rows shown (current page, expanded sub-rows included, group rows excluded). */
+  readonly rows: import("@angular/core").Signal<readonly T[]>;
+  /** Query of the server data source (`pageSize` 0 = every row, when not pageable). */
+  readonly query: import("@angular/core").Signal<SirioGridQuery>;
+  private readonly selectedKeys;
+  /** Rows of the page that can be selected (`rowSelectable`), the target of "select all". */
+  /** Mode of "seleziona tutto" in use (a server data source has only the loaded page). */
+  protected readonly selectAllMode: import("@angular/core").Signal<SirioGridSelectAll>;
+  /** Selectable rows taken by "seleziona tutto" (`selectAll`): page, filtered rows or every row. */
+  protected readonly selectableRows: import("@angular/core").Signal<T[]>;
+  protected readonly pageSelectedCount: import("@angular/core").Signal<number>;
+  protected readonly allPageSelected: import("@angular/core").Signal<boolean>;
+  /** Label of the "seleziona tutto" checkbox. */
+  protected readonly selectAllText: import("@angular/core").Signal<string>;
+  /** The row can be selected (selection active and `rowSelectable`). */
+  canSelect(row: T): boolean;
+  protected readonly status: import("@angular/core").Signal<string>;
+  constructor();
+  /** Calls the data source again with the current query. */
+  reload(): void;
+  /** Identity of a row (`rowId`). */
+  keyOf(row: T): unknown;
+  isSelected(row: T): boolean;
+  /** Selects or deselects a row (single: selects it). */
+  toggleRow(row: T, force?: boolean): void;
+  /** Selects or deselects the selectable rows of "seleziona tutto" (`selectAll`: page, filtered rows or every row). */
+  toggleAll(selected?: boolean): void;
+  /** Changes of the form array (values, rows, status, touched): the rows are read again. */
+  private readonly formTick;
+  /** Value object of each form group, reused while its value does not change (stable rows). */
+  private readonly formValues;
+  /** Form group of each value object shown. */
+  private readonly rowGroups;
+  /** Form array editing active: a form array and no server data source. */
+  protected readonly formMode: import("@angular/core").Signal<boolean>;
+  /** Values of the form array rows (null without a form array). */
+  private readonly formRows;
+  /** Rows of the client side grid: the form array values or `data`. */
+  private readonly localRows;
+  /** The form array (or a parent of it) is disabled: rows can only be viewed. */
+  protected readonly formDisabled: import("@angular/core").Signal<boolean>;
+  /** Column of the row actions (edit / view, delete) at the right end. */
+  protected readonly actionsColumn: import("@angular/core").Signal<boolean>;
+  /** "Aggiungi" shown. */
+  protected readonly canAdd: import("@angular/core").Signal<boolean>;
+  /** Selected rows that can be removed ("Elimina selezionati"). */
+  protected readonly deletableSelected: import("@angular/core").Signal<T[]>;
+  /** Error of the form array shown under the grid (after it is touched or changed). */
+  protected readonly formError: import("@angular/core").Signal<string | null>;
+  private readonly globalMessages;
+  private readonly dialogs;
+  /** Edit dialog: the session shown (the template stays while the dialog closes). */
+  protected readonly editing: import("@angular/core").WritableSignal<EditSession<T> | null>;
+  protected readonly editorOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly saving: import("@angular/core").WritableSignal<boolean>;
+  protected readonly saveError: import("@angular/core").WritableSignal<string | null>;
+  protected readonly editorTitle: import("@angular/core").Signal<string>;
+  /** Value object of a form group: the same object while the value does not change. */
+  private formValueOf;
+  /** Form group of a row of a `[formArray]` grid (null for other rows). */
+  groupOf(row: T): FormGroup | null;
+  /** Position of a row in the form array (-1 if it is not there). */
+  indexOf(row: T): number;
+  /** The row can be changed in the dialog (otherwise it opens read-only). */
+  canEdit(row: T): boolean;
+  /** The row can be removed. */
+  canDelete(row: T): boolean;
+  /** The row has errors (shown once it, or the form array, is touched). */
+  protected rowInvalid(row: T): boolean;
+  /**
+   * Opens the dialog of a row: a copy of its group (`rowFactory`, or a generic copy) applied by
+   * "Salva"; read-only when the row cannot be changed.
+   */
+  editRow(row: T): void;
+  /** Opens the dialog of a new row (`rowFactory` with the initial values), added at the end by "Salva". */
+  addRow(initial?: Partial<T> | null): void;
+  /** Closes the edit dialog without saving. */
+  closeEditor(): void;
+  private openEditor;
+  /** Dialog open: the focus goes to the first field of the form. */
+  protected onEditorOpened(): void;
+  protected onEditorClosed(): void;
+  /** "Salva": validation (pending validators awaited), `saveHandler`, then the change of the form array. */
+  saveEditor(): Promise<boolean>;
+  private focusFirstError;
+  /** Removes a row (confirmation, `deleteHandler`); resolves true once it is removed. */
+  deleteRow(row: T): Promise<boolean>;
+  /** Removes the selected rows that can be removed (one confirmation). */
+  deleteSelected(): Promise<number>;
+  private confirmRemoval;
+  private removeRow;
+  /** Double click on a row: its dialog. */
+  protected onRowDoubleClick(row: SirioGridRow<T>, event: MouseEvent): void;
+  /** Label of a row action: "<action> <row name>". */
+  protected actionLabel(action: string, row: T, index: number): string;
+  /** Follows the form array: its events refresh the rows; the selection follows the edited rows. */
+  private watchFormArray;
+  /** Classes and styles of a data row (`rowClass`, `rowStyle`). */
+  protected rowLook(row: T, index: number): {
+    cls: string;
+    style: Record<string, string> | null;
+  };
+  /** Classes (alignment, `cellClass`) and styles (`cellStyle`) of a data cell. */
+  protected cellLook(column: SirioGridColumn<T>, row: T): {
+    cls: string;
+    style: Record<string, string> | null;
+  };
+  /** Expands (or collapses) every row: groups, tree rows and detail rows. */
+  expandAll(expanded?: boolean): void;
+  /** Expands or collapses one row (by its row id). */
+  toggleExpanded(rowId: string, expanded?: boolean): void;
+  protected setGrouping(keys: string[] | null): void;
+  /** Group row: the column it groups by. */
+  protected groupColumnOf(row: SirioGridRow<T>): SirioGridColumn<T> | undefined;
+  /** Text of an aggregated value (group rows). */
+  protected aggregateText(column: SirioGridColumn<T>, row: SirioGridRow<T>): string;
+  /** First data column of the rendered order: it holds the tree / group indentation. */
+  protected readonly firstColumn: import("@angular/core").Signal<SirioGridColumn<T>>;
+  protected indentOf(row: SirioGridRow<T>): number;
+  protected expandLabel(row: SirioGridRow<T>, text: string): string;
+  /**
+   * Sorts by a column: asc → desc → none. With `sortMode="multiple"` and `add` (Shift) the column
+   * is added to (or cycled within) the current criteria; otherwise it replaces them.
+   */
+  sortBy(column: SirioGridColumn<T>, add?: boolean): void;
+  protected directionOf(column: SirioGridColumn<T>): 'asc' | 'desc' | null;
+  /** Priority (1-based) of a sorted column when more columns are sorted; 0 otherwise. */
+  protected sortIndexOf(column: SirioGridColumn<T>): number;
+  protected ariaSortOf(column: SirioGridColumn<T>): string | null;
+  protected onHeaderClick(column: SirioGridColumn<T>, event: MouseEvent): void;
+  /**
+   * Keys of a focused header, as ag-grid: Enter / Space sort (Shift: multiple sort), Alt+arrows
+   * resize, Shift+arrows move the column, Ctrl+Enter opens its filter. Alt+arrows are always taken
+   * on a header: Alt+Left is "back" in the browsers and would leave the page (and the form).
+   */
+  protected onHeaderKey(column: SirioGridColumn<T>, event: KeyboardEvent): void;
+  /** Opens the filter of a column from its header (its button in the header or in the filter row). */
+  private openFilterOf;
+  protected headerFocusable(column: SirioGridColumn<T>): boolean;
+  protected headerHintId(column: SirioGridColumn<T>): string | null;
+  /** Moves a column by `delta` positions (negative = towards the start). */
+  moveColumn(column: SirioGridColumn<T>, delta: number, keepFocus?: boolean): void;
+  /** Moves a column next to another one (drag and drop). */
+  private moveColumnTo;
+  private applyOrder;
+  protected onDragStart(column: SirioGridColumn<T>, event: DragEvent): void;
+  protected onDragOver(column: SirioGridColumn<T>, event: DragEvent): void;
+  protected onDrop(event: DragEvent): void;
+  protected onDragEnd(): void;
+  /** Width of a column (px) in the resized / flex layout. */
+  protected widthOf(column: SirioGridColumn<T>): number;
+  /**
+   * Minimum width of a header with a declared pixel `width` in the automatic layout: when the table
+   * is wider than the grid the browser shrinks every column towards its content, also those with a
+   * width (e.g. a date column of 300px shown at 200px). The fixed layout uses the widths as they are.
+   */
+  protected cssMinWidthOf(column: SirioGridColumn<T>): string | null;
+  /** CSS width of a header: the resized width, or the declared `width`. */
+  protected cssWidthOf(column: SirioGridColumn<T>): string | null;
+  protected canResize(column: SirioGridColumn<T>): boolean;
+  /** Sets the width of a column (clamped to its min/max); the other columns keep their width. */
+  setColumnWidth(column: SirioGridColumn<T>, width: number): void;
+  /** Back to the automatic layout and the declaration order of the columns. */
+  resetColumns(): void;
+  /**
+   * First resize: the current widths of every visible column become the fixed widths (the flex
+   * columns keep filling the free width, unless they are resized themselves).
+   */
+  private seedWidths;
+  protected onResizeStart(column: SirioGridColumn<T>, event: PointerEvent): void;
+  /** Back to the width the column had before resizing (a flex column is sized by `flex` again). */
+  resetColumnWidth(column: SirioGridColumn<T>): void;
+  /** Value of the filter of a column. */
+  filterValueOf(column: SirioGridColumn<T>): unknown;
+  /** Sets the filter of a column (null or empty clears it). */
+  setFilter(column: SirioGridColumn<T> | string, value: unknown, immediate?: boolean): void;
+  /** Removes the filter of a column. */
+  clearFilter(column: SirioGridColumn<T> | string): void;
+  /** Operator chosen for a column while its value is still empty (the filter is not active yet). */
+  private readonly operatorDrafts;
+  /** Operators of a column filter (empty = simple filter). */
+  protected operatorsOf(column: SirioGridColumn<T>): readonly SirioGridFilterOperator[];
+  /** Label of an operator (`filterOperatorLabels` over the Italian defaults). */
+  protected operatorLabel(operator: SirioGridFilterOperator): string;
+  protected operatorOptions(column: SirioGridColumn<T>): SirioOption<SirioGridFilterOperator>[];
+  /**
+   * Condition of a column with operators: its filter value, a simple value converted (e.g. a
+   * restored state: text → contains, range → between, list → in), or the chosen / default operator.
+   */
+  protected conditionOf(column: SirioGridColumn<T>): SirioGridFilterCondition;
+  /** Chooses the operator of a column filter (the value is kept, dropped for blank / not blank). */
+  protected setOperator(column: SirioGridColumn<T>, operator: SirioGridFilterOperator | null): void;
+  /** Sets the value (or the upper bound of `between`) of a column filter with operators. */
+  protected setConditionPart(column: SirioGridColumn<T>, part: 'value' | 'to', value: unknown, immediate?: boolean): void;
+  /**
+   * Field of a column in the filter row: the value of a simple condition (text, a number or a day,
+   * one option, yes / no, or the value of a single-value operator), otherwise a summary of the filter
+   * (e.g. "compreso tra", "vuoto", several options) changed from the popover.
+   */
+  protected inlineFilterOf(column: SirioGridColumn<T>): InlineFilter;
+  /**
+   * Value typed or chosen in the filter row: the value of the current operator, or the simple
+   * filter (a number or a day as a one-value range, one option as a list with `filterMultiple`).
+   */
+  protected setInlineFilter(column: SirioGridColumn<T>, value: unknown, immediate?: boolean): void;
+  /** Current state as plain JSON (`getState()`), updated on every change. */
+  readonly state: import("@angular/core").Signal<SirioGridState>;
+  /**
+   * State of the grid to save (sort, filters, page and page size, column order and widths,
+   * grouping, expanded rows, keys of the selected rows), e.g. in `localStorage` or on the server.
+   */
+  getState(): SirioGridState;
+  /**
+   * Restores a saved state (only the parts present; the others stay as they are). Filters apply at
+   * once, without going back to the first page; sort criteria and filters of columns that no
+   * longer exist are dropped; selected keys are matched to the rows of `data` (or of the page
+   * loaded from `dataSource`).
+   */
+  setState(state: Partial<SirioGridState> | null | undefined): void;
+  /** Back to the initial state: no sort, filters, grouping, expansion or selection, first page, columns as declared. */
+  resetState(): void;
+  /** Removes every column filter. */
+  clearFilters(): void;
+  /**
+   * Choices of a select filter: `filterOptions`, or the values present in the column (TanStack
+   * faceted values, with the other filters applied) with their count.
+   */
+  protected filterOptionsOf(column: SirioGridColumn<T>): SirioOption[];
+  protected rangeOf(column: SirioGridColumn<T>): SirioGridRange;
+  protected setRange(column: SirioGridColumn<T>, bound: 'from' | 'to', value: unknown): void;
+  protected filterButtonLabel(column: SirioGridColumn<T>, inRow?: boolean): string;
+  protected filterIndex(column: SirioGridColumn<T>): number;
+  protected isFiltered(column: SirioGridColumn<T>): boolean;
+  /** Moves the focus into the filter popover of a column when it opens. */
+  protected focusFilter(column: SirioGridColumn<T>): void;
+  /** A 'yyyy-MM-dd' day in the date format of `LOCALE_ID`. */
+  private formatIsoDay;
+  protected onChipRemoved(chip: SirioFilterChip): void;
+  /** Text of a value of a column filter (number, date, select / boolean labels). */
+  private filterValueText;
+  /** Text of a filter value in its chip. */
+  protected filterText(column: SirioGridColumn<T>, value: unknown): string;
+  protected onRowActivate(row: SirioGridRow<T>, index: number, event: MouseEvent | KeyboardEvent): void;
+  /** Space / Enter on a focused row selects it (rows without the checkbox column). */
+  protected onRowKey(row: SirioGridRow<T>, index: number, event: KeyboardEvent): void;
+  /**
+   * Focus inside the grid (keyboard navigation): the focused cell is scrolled fully into
+   * view, out from under the fixed blocks and the fixed header. The browser scrolls a partly visible
+   * element only when it is fully out of view, and does not know about the sticky cells.
+   */
+  protected revealFocused(event: FocusEvent): void;
+  protected onPaged(): void;
+  protected updateOverflow(): void;
+  /**
+   * Total after a server page: the one of the response, otherwise found from the pages received for
+   * the same query (as ag-grid infinite model): a page shorter than `pageSize` is the last one, a full
+   * page leaves the total open.
+   */
+  private nextServerTotal;
+  private load;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDataGrid<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SirioDataGrid<any>, "wm-sirio-data-grid", never, {
+    "data": {
+      "alias": "data";
+      "required": false;
+      "isSignal": true;
+    };
+    "dataSource": {
+      "alias": "dataSource";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowId": {
+      "alias": "rowId";
+      "required": false;
+      "isSignal": true;
+    };
+    "subRows": {
+      "alias": "subRows";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "formArray": {
+      "alias": "formArray";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowFactory": {
+      "alias": "rowFactory";
+      "required": false;
+      "isSignal": true;
+    };
+    "addable": {
+      "alias": "addable";
+      "required": false;
+      "isSignal": true;
+    };
+    "deletable": {
+      "alias": "deletable";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowEditable": {
+      "alias": "rowEditable";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowDeletable": {
+      "alias": "rowDeletable";
+      "required": false;
+      "isSignal": true;
+    };
+    "editOnDoubleClick": {
+      "alias": "editOnDoubleClick";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirmDelete": {
+      "alias": "confirmDelete";
+      "required": false;
+      "isSignal": true;
+    };
+    "saveHandler": {
+      "alias": "saveHandler";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleteHandler": {
+      "alias": "deleteHandler";
+      "required": false;
+      "isSignal": true;
+    };
+    "editorSize": {
+      "alias": "editorSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessages": {
+      "alias": "errorMessages";
+      "required": false;
+      "isSignal": true;
+    };
+    "sort": {
+      "alias": "sort";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortMode": {
+      "alias": "sortMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageable": {
+      "alias": "pageable";
+      "required": false;
+      "isSignal": true;
+    };
+    "page": {
+      "alias": "page";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSizeOptions": {
+      "alias": "pageSizeOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginationVariant": {
+      "alias": "paginationVariant";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginationSiblings": {
+      "alias": "paginationSiblings";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginationShowItems": {
+      "alias": "paginationShowItems";
+      "required": false;
+      "isSignal": true;
+    };
+    "selection": {
+      "alias": "selection";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "filters": {
+      "alias": "filters";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterDebounce": {
+      "alias": "filterDebounce";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterOperators": {
+      "alias": "filterOperators";
+      "required": false;
+      "isSignal": true;
+    };
+    "showFilterChips": {
+      "alias": "showFilterChips";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterButton": {
+      "alias": "filterButton";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterRow": {
+      "alias": "filterRow";
+      "required": false;
+      "isSignal": true;
+    };
+    "grouping": {
+      "alias": "grouping";
+      "required": false;
+      "isSignal": true;
+    };
+    "expanded": {
+      "alias": "expanded";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowExpandable": {
+      "alias": "rowExpandable";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowNumbers": {
+      "alias": "rowNumbers";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectOnRowClick": {
+      "alias": "selectOnRowClick";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionColumn": {
+      "alias": "selectionColumn";
+      "required": false;
+      "isSignal": true;
+    };
+    "keyboardNavigation": {
+      "alias": "keyboardNavigation";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowSelectable": {
+      "alias": "rowSelectable";
+      "required": false;
+      "isSignal": true;
+    };
+    "hideUnselectable": {
+      "alias": "hideUnselectable";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectAll": {
+      "alias": "selectAll";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowClass": {
+      "alias": "rowClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowStyle": {
+      "alias": "rowStyle";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizable": {
+      "alias": "resizable";
+      "required": false;
+      "isSignal": true;
+    };
+    "reorderable": {
+      "alias": "reorderable";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnWidths": {
+      "alias": "columnWidths";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnOrder": {
+      "alias": "columnOrder";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "responsive": {
+      "alias": "responsive";
+      "required": false;
+      "isSignal": true;
+    };
+    "stickyHeader": {
+      "alias": "stickyHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "fixedFirstColumn": {
+      "alias": "fixedFirstColumn";
+      "required": false;
+      "isSignal": true;
+    };
+    "fixedLastColumn": {
+      "alias": "fixedLastColumn";
+      "required": false;
+      "isSignal": true;
+    };
+    "height": {
+      "alias": "height";
+      "required": false;
+      "isSignal": true;
+    };
+    "minHeight": {
+      "alias": "minHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxHeight": {
+      "alias": "maxHeight";
+      "required": false;
+      "isSignal": true;
+    };
+    "cardOnMobile": {
+      "alias": "cardOnMobile";
+      "required": false;
+      "isSignal": true;
+    };
+    "caption": {
+      "alias": "caption";
+      "required": false;
+      "isSignal": true;
+    };
+    "captionVisible": {
+      "alias": "captionVisible";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingText": {
+      "alias": "loadingText";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadErrorText": {
+      "alias": "loadErrorText";
+      "required": false;
+      "isSignal": true;
+    };
+    "retryLabel": {
+      "alias": "retryLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "moreLabel": {
+      "alias": "moreLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "resultsLabel": {
+      "alias": "resultsLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectAllLabel": {
+      "alias": "selectAllLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectRowHint": {
+      "alias": "selectRowHint";
+      "required": false;
+      "isSignal": true;
+    };
+    "singleSelectionControl": {
+      "alias": "singleSelectionControl";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionHeaderLabel": {
+      "alias": "selectionHeaderLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectRowLabel": {
+      "alias": "selectRowLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortAscendingLabel": {
+      "alias": "sortAscendingLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortDescendingLabel": {
+      "alias": "sortDescendingLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiSortHint": {
+      "alias": "multiSortHint";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginationAriaLabel": {
+      "alias": "paginationAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterLabel": {
+      "alias": "filterLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterFromLabel": {
+      "alias": "filterFromLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterToLabel": {
+      "alias": "filterToLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterAllLabel": {
+      "alias": "filterAllLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterMoreLabel": {
+      "alias": "filterMoreLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterYesLabel": {
+      "alias": "filterYesLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterNoLabel": {
+      "alias": "filterNoLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterActiveLabel": {
+      "alias": "filterActiveLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearFilterLabel": {
+      "alias": "clearFilterLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearFiltersLabel": {
+      "alias": "clearFiltersLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterConditionLabel": {
+      "alias": "filterConditionLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterValueLabel": {
+      "alias": "filterValueLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterAndLabel": {
+      "alias": "filterAndLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterOperatorLabels": {
+      "alias": "filterOperatorLabels";
+      "required": false;
+      "isSignal": true;
+    };
+    "filtersLabel": {
+      "alias": "filtersLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowNumberHeader": {
+      "alias": "rowNumberHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowNumberLabel": {
+      "alias": "rowNumberLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "groupByLabel": {
+      "alias": "groupByLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandAllLabel": {
+      "alias": "expandAllLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapseAllLabel": {
+      "alias": "collapseAllLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowName": {
+      "alias": "rowName";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandRowLabel": {
+      "alias": "expandRowLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapseRowLabel": {
+      "alias": "collapseRowLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizeColumnLabel": {
+      "alias": "resizeColumnLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "reorderHint": {
+      "alias": "reorderHint";
+      "required": false;
+      "isSignal": true;
+    };
+    "resizeHint": {
+      "alias": "resizeHint";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterHint": {
+      "alias": "filterHint";
+      "required": false;
+      "isSignal": true;
+    };
+    "resetColumnsLabel": {
+      "alias": "resetColumnsLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnMovedLabel": {
+      "alias": "columnMovedLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "actionsHeader": {
+      "alias": "actionsHeader";
+      "required": false;
+      "isSignal": true;
+    };
+    "addLabel": {
+      "alias": "addLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "editLabel": {
+      "alias": "editLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "viewLabel": {
+      "alias": "viewLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleteLabel": {
+      "alias": "deleteLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleteSelectedLabel": {
+      "alias": "deleteSelectedLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "newRowTitle": {
+      "alias": "newRowTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "editRowTitle": {
+      "alias": "editRowTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "viewRowTitle": {
+      "alias": "viewRowTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "saveLabel": {
+      "alias": "saveLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelLabel": {
+      "alias": "cancelLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleteConfirmTitle": {
+      "alias": "deleteConfirmTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleteSelectedConfirmTitle": {
+      "alias": "deleteSelectedConfirmTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleteConfirmMessage": {
+      "alias": "deleteConfirmMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "invalidRowLabel": {
+      "alias": "invalidRowLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "saveErrorTitle": {
+      "alias": "saveErrorTitle";
       "required": false;
       "isSignal": true;
     };
-    "nextLabel": {
-      "alias": "nextLabel";
+    "saveErrorText": {
+      "alias": "saveErrorText";
       "required": false;
       "isSignal": true;
     };
   }, {
+    "sort": "sortChange";
     "page": "pageChange";
     "pageSize": "pageSizeChange";
-    "paged": "paged";
-  }, never, ["*"], true, never>;
+    "selected": "selectedChange";
+    "filters": "filtersChange";
+    "grouping": "groupingChange";
+    "expanded": "expandedChange";
+    "columnWidths": "columnWidthsChange";
+    "columnOrder": "columnOrderChange";
+    "rowClick": "rowClick";
+    "loadError": "loadError";
+    "stateChange": "stateChange";
+    "rowSave": "rowSave";
+    "rowDelete": "rowDelete";
+  }, ["columns", "emptyTemplate", "detailTemplate", "errorTemplate", "editorTemplate"], never, true, never>;
+}
+/** The grid with its column and template directives, for `imports: [SIRIO_DATA_GRID]`. */
+export declare const SIRIO_DATA_GRID: readonly [typeof SirioDataGrid, typeof SirioGridColumn, typeof SirioGridCell, typeof SirioGridHeader, typeof SirioGridEmpty, typeof SirioGridDetail, typeof SirioGridEditor, typeof SirioGridError];
+/** Field of a column in the filter row (`inlineFilterOf`). */
+interface InlineFilter {
+  kind: 'text' | 'number' | 'date' | 'select' | 'summary';
+  value: unknown;
+  placeholder: string;
+  summary?: string;
 }
 /** Duration of the kit collapse transition (`[data-sirio-visible=collapsing]`, .35s). */
 declare const SIRIO_COLLAPSE_MS = 350;
@@ -3365,6 +5979,13 @@ export declare class SirioDashboard {
   readonly scrollTopOnNavigate: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Kit open/close animation of the submenus. */
   readonly animated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Page landmarks of the layout (default): top bar as banner (`<header>`), menu as complementary
+   * (`<aside>`), content as `<main>`. False for a dashboard placed inside a page that already has
+   * them (e.g. an embedded example): the content is a region named `contentLabel`, the menu a region
+   * named `sidebarLabel`, the top bar a group, so that the page keeps a single main landmark.
+   */
+  readonly landmarks: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   readonly menuLabel: import("@angular/core").InputSignal<string>;
   readonly collapseLabel: import("@angular/core").InputSignal<string>;
   readonly expandLabel: import("@angular/core").InputSignal<string>;
@@ -3375,6 +5996,10 @@ export declare class SirioDashboard {
   readonly commandsLabel: import("@angular/core").InputSignal<string>;
   readonly userPanelLabel: import("@angular/core").InputSignal<string>;
   readonly skipLinkLabel: import("@angular/core").InputSignal<string>;
+  /** Name of the content region with `landmarks` false. */
+  readonly contentLabel: import("@angular/core").InputSignal<string>;
+  /** Name of the menu region with `landmarks` false. */
+  readonly sidebarLabel: import("@angular/core").InputSignal<string>;
   /** Click on a command (also run by its `action`). */
   readonly commandClick: import("@angular/core").OutputEmitterRef<SirioDashboardCommandClick>;
   /** Click on a menu entry without children. */
@@ -3612,6 +6237,11 @@ export declare class SirioDashboard {
       "required": false;
       "isSignal": true;
     };
+    "landmarks": {
+      "alias": "landmarks";
+      "required": false;
+      "isSignal": true;
+    };
     "menuLabel": {
       "alias": "menuLabel";
       "required": false;
@@ -3662,6 +6292,16 @@ export declare class SirioDashboard {
       "required": false;
       "isSignal": true;
     };
+    "contentLabel": {
+      "alias": "contentLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sidebarLabel": {
+      "alias": "sidebarLabel";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "collapsed": "collapsedChange";
     "menuOpen": "menuOpenChange";
@@ -3675,212 +6315,6 @@ export declare class SirioDashboard {
 }
 /** Dashboard and its content slots, for `imports: [SIRIO_DASHBOARD_COMPONENTS]`. */
 export declare const SIRIO_DASHBOARD_COMPONENTS: readonly [typeof SirioDashboard, typeof SirioDashboardLogo, typeof SirioDashboardToolbar, typeof SirioDashboardUserPanel, typeof SirioDashboardSidebarFooter];
-/** Sizes of the kit dialog (`.sirio-dialog-wrapper` modifiers); default 600px. */
-export type SirioDialogSize = 'sm' | 'default' | 'lg' | 'xl';
-/** Color of the title icon (kit examples: default blue, "Avvertimento", "Pericolo"). */
-export type SirioDialogTone = 'default' | 'warning' | 'danger';
-/**
- * Footer of a dialog (kit `.sirio-dialog-footer`), with the action buttons:
- * `<div wmSirioDialogFooter>...</div>`.
- */
-export declare class SirioDialogFooter {
-  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDialogFooter, never>;
-  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioDialogFooter, "[wmSirioDialogFooter]", never, {}, {}, never, never, true, never>;
-}
-/**
- * Closes the enclosing dialog when clicked (kit `data-sirio-dismiss="dialog"`):
- * `<button wmSirioButton="secondary" wmSirioDialogClose>Annulla</button>`.
- * With a value (`[wmSirioDialogClose]="true"`) the value is emitted by the dialog `(closed)`.
- */
-export declare class SirioDialogClose {
-  /** Result reported by the dialog `(closed)` output. */
-  readonly result: import("@angular/core").InputSignal<unknown>;
-  private readonly dialog;
-  protected close(): void;
-  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDialogClose, never>;
-  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioDialogClose, "[wmSirioDialogClose]", never, {
-    "result": {
-      "alias": "wmSirioDialogClose";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {}, never, never, true, never>;
-}
-/**
- * Dialog of the Sirio web kit ("Dialog"): `.sirio-dialog` (backdrop) > `.sirio-dialog-wrapper`
- * (size `sm` / `lg` / `xl`, `dialog-centered`) > `.sirio-dialog-content` with header
- * (`h2.sirio-dialog-title` with the icon, close button `.sirio-btn-close`), body and footer.
- *
- * Behaviour of the kit script (SirioDialog) reproduced in Angular: `aria-modal`, focus moved into
- * the dialog when it opens and back to the previously focused element when it closes, Esc and a
- * click on the backdrop close it. In addition: `role="dialog"` (`alertdialog` with `alert`), focus kept
- * inside the dialog (Tab / Shift+Tab), page scroll locked while open.
- *
- * With `drawer` it is the kit drawer (`.sirio-drawer`): a panel opening from the right. Inside a component
- * opened by `SirioDialogService.open()` the dialog opens by itself and closes the `SirioDialogRef`.
- *
- * ```html
- * <wm-sirio-dialog [(open)]="confirmOpen" title="Vuoi eliminare il tuo account?" tone="danger" alert
- *               (closed)="onClosed($event)">
- *   <p>L'operazione non è reversibile.</p>
- *   <div wmSirioDialogFooter>
- *     <button wmSirioButton="ghost" type="button" wmSirioDialogClose>Annulla</button>
- *     <button wmSirioButton="danger" type="button" [wmSirioDialogClose]="true">Elimina</button>
- *   </div>
- * </wm-sirio-dialog>
- * ```
- */
-export declare class SirioDialog {
-  /** Visibility (two-way: `[(open)]`). */
-  readonly open: import("@angular/core").ModelSignal<boolean>;
-  readonly title: import("@angular/core").InputSignal<string>;
-  /** Accessible name when there is no title. */
-  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
-  /** Font Awesome icon of the title (kit: `fa-exclamation-circle`); null = no icon. */
-  readonly icon: import("@angular/core").InputSignal<string | null>;
-  /** Color of the icon: default (blue), warning (`sirio-text-warning`), danger (`sirio-text-danger`). */
-  readonly tone: import("@angular/core").InputSignal<SirioDialogTone>;
-  readonly size: import("@angular/core").InputSignal<SirioDialogSize>;
-  /** Vertically centered (kit `dialog-centered`). */
-  readonly centered: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  /** Close button in the header (kit). */
-  readonly dismissible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  readonly closeLabel: import("@angular/core").InputSignal<string>;
-  /** Esc and a click on the backdrop close the dialog (kit behaviour). */
-  readonly closeOnEscape: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  readonly closeOnBackdrop: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  /** `role="alertdialog"` for confirmations that interrupt the user (e.g. destructive actions). */
-  readonly alert: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  /** Kit drawer: panel opening from the right (`.sirio-drawer`). */
-  readonly drawer: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  /** Extra classes of the `.sirio-dialog` element (e.g. kit drawer / side panel classes). */
-  readonly panelClass: import("@angular/core").InputSignal<string>;
-  /**
-   * The panel is also shown in the page while closed (kit side filters: `d-lg-flex` on desktop):
-   * it is a dialog (`role`, focus trap) only when open.
-   */
-  readonly inline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-  /** Emitted after the dialog opens. */
-  readonly opened: import("@angular/core").OutputEmitterRef<void>;
-  /** Emitted when the dialog closes, with the result of `wmSirioDialogClose` (undefined otherwise). */
-  readonly closed: import("@angular/core").OutputEmitterRef<unknown>;
-  protected readonly footer: import("@angular/core").Signal<SirioDialogFooter | undefined>;
-  private readonly dialogRef;
-  private readonly document;
-  private readonly injector;
-  /** Reference of a dialog opened from code, when this is its dialog (see SirioDialogService.open). */
-  private readonly openedRef;
-  private readonly baseId;
-  protected readonly dialogId: string;
-  protected readonly titleId: string;
-  protected readonly iconClasses: import("@angular/core").Signal<string>;
-  /** Element focused before opening (focus returns there on close). */
-  private returnFocus;
-  private pendingResult;
-  private backdropPressed;
-  /** The opening steps ran (focus saved, scroll locked) and the closing ones did not yet. */
-  private shown;
-  constructor();
-  /** Opens the dialog (kit SirioDialog.show()). */
-  show(): void;
-  /** Closes the dialog (kit SirioDialog.hide()); `result` is emitted by `(closed)`. */
-  close(result?: unknown): void;
-  toggle(): void;
-  protected onKeydown(event: KeyboardEvent): void;
-  /** Backdrop click: the press and the release must both happen on the backdrop. */
-  protected onBackdropMousedown(event: MouseEvent): void;
-  protected onBackdropClick(event: MouseEvent): void;
-  private isBackdrop;
-  private onOpen;
-  private onClose;
-  private trapFocus;
-  private lockScroll;
-  private unlockScroll;
-  static ɵfac: i0.ɵɵFactoryDeclaration<SirioDialog, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<SirioDialog, "wm-sirio-dialog", never, {
-    "open": {
-      "alias": "open";
-      "required": false;
-      "isSignal": true;
-    };
-    "title": {
-      "alias": "title";
-      "required": false;
-      "isSignal": true;
-    };
-    "ariaLabel": {
-      "alias": "ariaLabel";
-      "required": false;
-      "isSignal": true;
-    };
-    "icon": {
-      "alias": "icon";
-      "required": false;
-      "isSignal": true;
-    };
-    "tone": {
-      "alias": "tone";
-      "required": false;
-      "isSignal": true;
-    };
-    "size": {
-      "alias": "size";
-      "required": false;
-      "isSignal": true;
-    };
-    "centered": {
-      "alias": "centered";
-      "required": false;
-      "isSignal": true;
-    };
-    "dismissible": {
-      "alias": "dismissible";
-      "required": false;
-      "isSignal": true;
-    };
-    "closeLabel": {
-      "alias": "closeLabel";
-      "required": false;
-      "isSignal": true;
-    };
-    "closeOnEscape": {
-      "alias": "closeOnEscape";
-      "required": false;
-      "isSignal": true;
-    };
-    "closeOnBackdrop": {
-      "alias": "closeOnBackdrop";
-      "required": false;
-      "isSignal": true;
-    };
-    "alert": {
-      "alias": "alert";
-      "required": false;
-      "isSignal": true;
-    };
-    "drawer": {
-      "alias": "drawer";
-      "required": false;
-      "isSignal": true;
-    };
-    "panelClass": {
-      "alias": "panelClass";
-      "required": false;
-      "isSignal": true;
-    };
-    "inline": {
-      "alias": "inline";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "open": "openChange";
-    "opened": "opened";
-    "closed": "closed";
-  }, ["footer"], ["*", "[wmSirioDialogFooter]"], true, never>;
-}
-/** Dialog components, for `imports: [SIRIO_DIALOG]`. */
-export declare const SIRIO_DIALOG: readonly [typeof SirioDialog, typeof SirioDialogFooter, typeof SirioDialogClose];
 /** @internal The part of SirioDialog used by SirioDialogRef. */
 export interface SirioDialogCloser {
   close(result?: unknown): void;
@@ -4102,6 +6536,8 @@ export declare class SirioStepper {
 /** Heading level of the accordion headers: `null` = `div` (kit example), 2–6 = `h2`…`h6`. */
 export type SirioHeadingLevel = 2 | 3 | 4 | 5 | 6 | null;
 /** Custom title of an accordion item: `<ng-template wmSirioAccordionTitle>...</ng-template>`. */
+/** When the panels of an accordion are regions (see `SirioAccordion.panelRegions`). */
+export type SirioAccordionPanelRegions = 'auto' | 'always' | 'never';
 export declare class SirioAccordionTitle {
   static ɵfac: i0.ɵɵFactoryDeclaration<SirioAccordionTitle, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<SirioAccordionTitle, "ng-template[wmSirioAccordionTitle]", never, {}, {}, never, never, true, never>;
@@ -4140,6 +6576,13 @@ export declare class SirioAccordionItem {
   private readonly baseId;
   protected readonly headerId: string;
   protected readonly bodyId: string;
+  /**
+   * The panel is a region (`role="region"`, named by its header and the `ariaLabel` of the accordion)
+   * according to `panelRegions` of the accordion: by default up to 6 sections, as the ARIA accordion
+   * pattern suggests (more regions crowd the landmarks of the page).
+   */
+  protected readonly isRegion: import("@angular/core").Signal<boolean>;
+  protected readonly regionLabelledBy: import("@angular/core").Signal<string>;
   /** @internal Trigger button (keyboard navigation of the accordion). */
   readonly host: HTMLElement;
   protected readonly level: import("@angular/core").Signal<SirioHeadingLevel>;
@@ -4231,8 +6674,20 @@ export declare class SirioAccordion {
    * with `[focusContent]="false"` is excluded.
    */
   readonly focusContent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Name of the accordion: it is part of the name of the panel regions ("Anagrafica, Dati generali"),
+   * so that sections with the same title in different accordions of a page are told apart.
+   */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Panels as regions: `auto` (default) up to 6 sections, as the ARIA accordion pattern suggests,
+   * `always` or `never`. A panel that is not a region keeps the link with its header button.
+   */
+  readonly panelRegions: import("@angular/core").InputSignal<SirioAccordionPanelRegions>;
   /** @internal */
   readonly groupId: string;
+  /** @internal Element with the `ariaLabel` text, referenced by the panel regions. */
+  readonly labelId: string;
   /** The sections, in order. */
   readonly items: import("@angular/core").Signal<readonly SirioAccordionItem[]>;
   /** Number of sections. */
@@ -4297,6 +6752,16 @@ export declare class SirioAccordion {
       "required": false;
       "isSignal": true;
     };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "panelRegions": {
+      "alias": "panelRegions";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, ["items"], ["*"], true, never>;
 }
 /** Accordion components, for `imports: [SIRIO_ACCORDION]`. */
@@ -4937,6 +7402,8 @@ export declare abstract class SirioDateTimeBase extends SirioControlBase<string>
  * The owning component stays the only writer of the text: the picker parses with the strict Sirio
  * parser, never rewrites the field on blur, and its selection follows the `date` input.
  * The picker element is inserted right after the input (wrap it in a `position: relative` box).
+ * Inside a box that clips its content (e.g. the scrolling data grid, where the date filters are) the
+ * open picker floats over the page, under the field, so it is never cut.
  *
  * Internal building block of wm-sirio-date and wm-sirio-datetime.
  */
@@ -4955,11 +7422,28 @@ export declare class SirioDatePickerDirective implements OnDestroy {
   private readonly locale;
   private readonly italian;
   private picker;
+  private readonly document;
+  private readonly nonce;
+  /** Open picker moved over the page: where it was, and the listeners that keep it under the field. */
+  private floating;
   constructor();
   ngOnDestroy(): void;
   protected onChangeDate(): void;
+  /** The arrows move the focused day: it is marked until the picker closes or the mouse is used. */
+  protected onKeydown(event: KeyboardEvent): void;
+  protected keyboard(on: boolean): void;
+  /** Once per page: the rule of the focused day (see KEYBOARD_CSS). */
+  private addKeyboardStyle;
   /** Gives the icon-only header buttons an accessible name for the current view. */
   protected labelHeader(): void;
+  /**
+   * Opened inside a box that clips its content: the picker goes to the end of the page body, fixed
+   * under the field (above it when there is no room below), following it while the page or the box
+   * scrolls.
+   */
+  protected float(): void;
+  /** Back in its place after the input when the picker closes. */
+  protected unfloat(): void;
   private create;
   /** Aligns the picker selection with the component value, without touching the text. */
   private select;
@@ -5450,6 +7934,8 @@ interface SelectItem<T> {
   /** "Select all" row of a multiple select. */
   isSelectAll: boolean;
   selected: boolean;
+  /** Row shown while the options are loading (`loading`). */
+  isLoading?: boolean;
 }
 /** Emitted by `optionSelected` when the user chooses an option (click, Enter, Space). */
 export interface SirioSelectOptionEvent<T = unknown> {
@@ -5506,8 +7992,19 @@ export declare class SirioSelect<T = unknown> extends SirioControlBase<T | T[]>
   readonly searchMinLength: import("@angular/core").InputSignalWithTransform<number, unknown>;
   /** Text of the row shown when the search finds nothing. */
   readonly noResultsText: import("@angular/core").InputSignal<string>;
+  /**
+   * Options still loading (e.g. from a service): the list shows `loadingText` with the kit spinner,
+   * the closed field shows it instead of the placeholder and a spinner, the combobox is aria-busy.
+   */
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly loadingText: import("@angular/core").InputSignal<string>;
   /** Accessible name of the reset button (searchable). */
   readonly resetLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Shows the reset button ("X") of the kit autocomplete that clears the search and the selection (searchable).
+   * Default false: the button is not rendered, the value is changed by choosing another option or cleared from code.
+   */
+  readonly clearable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Screen reader hint of the search field (as the sr-only text in the kit Autocomplete example). */
   readonly searchHint: import("@angular/core").InputSignal<string>;
   /** The model value must be one of the options (`sirioSelectValue` error otherwise). */
@@ -5624,11 +8121,26 @@ export declare class SirioSelect<T = unknown> extends SirioControlBase<T | T[]>
       "required": false;
       "isSignal": true;
     };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingText": {
+      "alias": "loadingText";
+      "required": false;
+      "isSignal": true;
+    };
     "resetLabel": {
       "alias": "resetLabel";
       "required": false;
       "isSignal": true;
     };
+    "clearable": {
+      "alias": "clearable";
+      "required": false;
+      "isSignal": true;
+    };
     "searchHint": {
       "alias": "searchHint";
       "required": false;