@wemake4u/form-controls 2.0.2 → 2.0.3

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

@@ -1,6 +1,6 @@
 import * as i0 from "@angular/core";
 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 { AbstractControl, ControlValueAccessor, FormArray, FormControl, FormGroup, ValidationErrors, Validator } from "@angular/forms";
 import { Options, Splide } from "@splidejs/splide";
 import { Observable } from "rxjs";
 import { Row } from "@tanstack/angular-table";
@@ -165,7 +165,17 @@ export declare class SirioInfoButton {
   readonly title: import("@angular/core").InputSignal<string>;
   /** Accessible name of the button (e.g. "Informazioni su Codice fiscale"). */
   readonly label: import("@angular/core").InputSignal<string>;
+  /**
+   * Id(s) of the element(s) whose text completes the accessible name after `label`
+   * (e.g. the label of the control). Use it when the label text is not available as a string,
+   * for instance when it is projected content: the name becomes "`label` <text of the element>".
+   */
+  readonly labelledBy: import("@angular/core").InputSignal<string | null>;
   readonly placement: import("@angular/core").InputSignal<SirioTooltipPlacement>;
+  /** Id of the button: referenced by its own aria-labelledby to prepend `label` to the name. */
+  protected readonly buttonId: string;
+  /** Self-reference first, so the name is "<aria-label> <referenced text>". */
+  protected readonly ariaLabelledBy: import("@angular/core").Signal<string | null>;
   protected readonly template: import("@angular/core").Signal<TemplateRef<unknown> | null>;
   static ɵfac: i0.ɵɵFactoryDeclaration<SirioInfoButton, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SirioInfoButton, "wm-sirio-info-button", never, {
@@ -184,6 +194,11 @@ export declare class SirioInfoButton {
       "required": false;
       "isSignal": true;
     };
+    "labelledBy": {
+      "alias": "labelledBy";
+      "required": false;
+      "isSignal": true;
+    };
     "placement": {
       "alias": "placement";
       "required": false;
@@ -313,6 +328,12 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
   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>;
+  /**
+   * Required marker (asterisk, aria-required) without validation, for hosts that validate the control on their own
+   * (e.g. a form player with its own required validator). A `[required]` binding next to `formControlName` also
+   * matches the Angular RequiredValidator directive, which adds Validators.required to the control; this input does not.
+   */
+  readonly requiredIndicator: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Disabled state when the component is used without Angular forms. */
   readonly disabledInput: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Per-control error-message overrides (merged on top of SIRIO_ERROR_MESSAGES). */
@@ -361,8 +382,19 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
   readonly pendingLabel: import("@angular/core").InputSignal<string>;
   /** Milliseconds before the spinner appears (fast validations show nothing). */
   readonly pendingDelay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Lets the user set the field to null: a reset button ("X", as in the kit autocomplete) inside the field,
+   * shown only while the field has a value and is editable and not required. Default false.
+   * Supported by textbox, number, date, time, datetime and single select; the radio group adds an option
+   * with value null instead, and a checkbox becomes a radio group yes / no / no answer.
+   */
+  readonly nullable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Accessible name of the reset button, followed by the label ("Nessun valore per Codice fiscale"). */
+  readonly nullLabel: import("@angular/core").InputSignal<string>;
   /** Accessible name of the info button. */
   readonly infoButtonLabel: import("@angular/core").Signal<string>;
+  /** Accessible name of the null reset button. */
+  readonly nullButtonLabel: import("@angular/core").Signal<string>;
   /** Id of the label text (without the info button), for aria-labelledby on fieldsets. */
   readonly labelTextId: import("@angular/core").Signal<string>;
   protected readonly value: import("@angular/core").WritableSignal<T | null>;
@@ -390,6 +422,8 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
    */
   readonly control: import("@angular/core").Signal<AbstractControl<any, any, any> | null>;
   readonly isRequired: import("@angular/core").Signal<boolean>;
+  /** The null reset button is shown: nullable, editable, not required and with a value. */
+  readonly showNullButton: import("@angular/core").Signal<boolean>;
   /** An async validator is running on the bound control (status PENDING). */
   readonly isPending: import("@angular/core").Signal<boolean>;
   /** The pending indicator is shown: PENDING for at least `pendingDelay` ms. */
@@ -468,6 +502,15 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
   protected sameValue(a: T | null, b: T | null): boolean;
   /** Equality of two values (or array items); controls with `compareWith` use it. */
   protected sameItem(a: unknown, b: unknown): boolean;
+  /** True when an internal value counts as "no value" for the null reset button. */
+  protected isNullValue(value: T | null): boolean;
+  /**
+   * Sets the field to null (reset button of `nullable`): clears what is shown, notifies the form
+   * and moves the focus back to the field (the button disappears).
+   */
+  setNull(): void;
+  /** Moves the focus to the main element of the control (the one with `inputId`). */
+  protected focusField(): void;
   /** Hook to convert the model value into the internal value (override when they differ). */
   protected fromModel(value: unknown): T | null;
   /** Hook to convert the internal value into the model value (override when they differ). */
@@ -519,6 +562,11 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
       "required": false;
       "isSignal": true;
     };
+    "requiredIndicator": {
+      "alias": "requiredIndicator";
+      "required": false;
+      "isSignal": true;
+    };
     "disabledInput": {
       "alias": "disabled";
       "required": false;
@@ -589,6 +637,16 @@ export declare abstract class SirioControlBase<T> implements ControlValueAccesso
       "required": false;
       "isSignal": true;
     };
+    "nullable": {
+      "alias": "nullable";
+      "required": false;
+      "isSignal": true;
+    };
+    "nullLabel": {
+      "alias": "nullLabel";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, never, never, true, never>;
 }
 /**
@@ -2857,10 +2915,20 @@ export declare function sirioCloneControl<C extends AbstractControl>(control: C)
  * @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';
+/**
+ * Sizes of the kit dialog (`.sirio-dialog-wrapper` modifiers); default 600px. `fullscreen` takes the whole window,
+ * with the body between header and footer, for content that needs room such as an editor.
+ */
+export type SirioDialogSize = 'sm' | 'default' | 'lg' | 'xl' | 'fullscreen';
 /** Color of the title icon (kit examples: default blue, "Avvertimento", "Pericolo"). */
 export type SirioDialogTone = 'default' | 'warning' | 'danger';
+/** Backdrop behind the dialog: `dark` = the kit one (dark blue; grey for the drawer), `light` = black at 50%. */
+export type SirioDialogBackdrop = 'dark' | 'light';
+/**
+ * Header of the dialog: `kit` = the kit one (the icon is a block above the title), `compact` = the icon inline before
+ * the title and less space around it, for dialogs with many fields.
+ */
+export type SirioDialogHeader = 'kit' | 'compact';
 /**
  * Footer of a dialog (kit `.sirio-dialog-footer`), with the action buttons:
  * `<div wmSirioDialogFooter>...</div>`.
@@ -2890,7 +2958,7 @@ export declare class SirioDialogClose {
 }
 /**
  * Dialog of the Sirio web kit ("Dialog"): `.sirio-dialog` (backdrop) > `.sirio-dialog-wrapper`
- * (size `sm` / `lg` / `xl`, `dialog-centered`) > `.sirio-dialog-content` with header
+ * (size `sm` / `lg` / `xl` / `fullscreen`, `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
@@ -2901,6 +2969,12 @@ export declare class SirioDialogClose {
  * 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`.
  *
+ * `backdrop="light"` puts the same black at 50% behind any dialog, drawer included, instead of the kit
+ * backdrop (dark blue for the dialog, an almost transparent grey for the drawer).
+ *
+ * `header="compact"` puts the title icon inline instead of in a block above the title, with less space around the
+ * header: the dialog is about 60px lower (for dialogs with many fields).
+ *
  * ```html
  * <wm-sirio-dialog [(open)]="confirmOpen" title="Vuoi eliminare il tuo account?" tone="danger" alert
  *               (closed)="onClosed($event)">
@@ -2935,6 +3009,10 @@ export declare class SirioDialog {
   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>;
+  /** Backdrop: `dark` (kit, default) or `light` (black at 50%, also for the drawer). */
+  readonly backdrop: import("@angular/core").InputSignalWithTransform<SirioDialogBackdrop, "" | SirioDialogBackdrop | null | undefined>;
+  /** Header: `kit` (default, the icon above the title) or `compact` (the icon inline, less space). */
+  readonly header: import("@angular/core").InputSignalWithTransform<SirioDialogHeader, "" | SirioDialogHeader | null | undefined>;
   /** Extra classes of the `.sirio-dialog` element (e.g. kit drawer / side panel classes). */
   readonly panelClass: import("@angular/core").InputSignal<string>;
   /**
@@ -3045,6 +3123,16 @@ export declare class SirioDialog {
       "required": false;
       "isSignal": true;
     };
+    "backdrop": {
+      "alias": "backdrop";
+      "required": false;
+      "isSignal": true;
+    };
+    "header": {
+      "alias": "header";
+      "required": false;
+      "isSignal": true;
+    };
     "panelClass": {
       "alias": "panelClass";
       "required": false;
@@ -3273,6 +3361,11 @@ export declare class SirioDataGrid<T extends object = any> {
   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>;
+  /**
+   * Shows "Espandi tutto" / "Comprimi tutto" above a grid with detail rows, tree rows or groups. Off for short
+   * grids that start expanded, where the buttons only add noise.
+   */
+  readonly expandAllTools: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /**
    * 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
@@ -3454,6 +3547,14 @@ export declare class SirioDataGrid<T extends object = any> {
   readonly collapseRowLabel: import("@angular/core").InputSignal<string>;
   /** Accessible label of the resize handle: "<label> <header>". */
   readonly resizeColumnLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Keyboard instructions of the grid pattern (WCAG 2.1 SC 3.3.2): read when the focus enters the
+   * table (aria-describedby), only with the keyboard navigation (role grid / treegrid). Users expect
+   * Tab to move between the buttons of a row: the arrows do it, Tab leaves the grid. Empty = none.
+   */
+  readonly navigationHint: import("@angular/core").InputSignal<string>;
+  /** aria-describedby of the table: the navigation hint with role grid / treegrid. */
+  protected readonly tableDescribedBy: import("@angular/core").Signal<string | null>;
   /** 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). */
@@ -4160,6 +4261,11 @@ export declare class SirioDataGrid<T extends object = any> {
       "required": false;
       "isSignal": true;
     };
+    "expandAllTools": {
+      "alias": "expandAllTools";
+      "required": false;
+      "isSignal": true;
+    };
     "rowNumbers": {
       "alias": "rowNumbers";
       "required": false;
@@ -4480,6 +4586,11 @@ export declare class SirioDataGrid<T extends object = any> {
       "required": false;
       "isSignal": true;
     };
+    "navigationHint": {
+      "alias": "navigationHint";
+      "required": false;
+      "isSignal": true;
+    };
     "reorderHint": {
       "alias": "reorderHint";
       "required": false;
@@ -4621,6 +4732,55 @@ interface InlineFilter {
   placeholder: string;
   summary?: string;
 }
+/** Sort criterion of a server-side query (same shape as remoting `OrderBy`). */
+export interface SirioRemoteSort {
+  colId: string;
+  sort: 'asc' | 'desc';
+}
+/** Ag-grid style filter model, by column key. */
+export type SirioRemoteFilterModel = Record<string, unknown>;
+/** Filter type by column key: the `filter` of the columns (default `text`). */
+export type SirioRemoteFilterTypes = Record<string, SirioGridFilterType>;
+/** Options of a server-side query (same shape as remoting `QueryOptions`). */
+export interface SirioRemoteQueryOptions {
+  count?: boolean;
+  top?: number;
+  skip?: number;
+  orderBy?: SirioRemoteSort[];
+  filter?: SirioRemoteFilterModel;
+  /**
+   * Total row count, written by the loader into the options it receives (remoting copies `$count`
+   * of the response here): it becomes the `total` of the grid result.
+   */
+  totalCount?: number;
+}
+export interface SirioRemoteGridSourceOptions {
+  /** Filters that are not grid columns (e.g. states chosen with chips), read at every query. */
+  extraFilter?: () => SirioRemoteFilterModel;
+  /**
+   * Filter type of the number, date, select and boolean columns: needed to translate the values and
+   * the conditions with operators (`filterOperators`), which have the same shape for dates and texts.
+   */
+  filterTypes?: SirioRemoteFilterTypes;
+}
+/**
+ * Data source of a grid with paging, sorting and filtering on the server: the grid query becomes
+ * `SirioRemoteQueryOptions` and the loader returns the rows (it is the counterpart of remoting
+ * `queryRows`, which does the same for ag-grid).
+ *
+ * ```ts
+ * readonly source = sirioRemoteGridSource(options => this.service.getItems(options), {
+ *   filterTypes: { version: 'number', created: 'date' }
+ * });
+ * ```
+ */
+export declare function sirioRemoteGridSource<T extends object>(load: (options: SirioRemoteQueryOptions) => Observable<T[] | null>, sourceOptions?: SirioRemoteGridSourceOptions): SirioGridDataSource<T>;
+/** Server-side query options of a grid query, with optional extra filters. */
+export declare function sirioToQueryOptions(query: SirioGridQuery, extraFilter?: SirioRemoteFilterModel, filterTypes?: SirioRemoteFilterTypes): SirioRemoteQueryOptions;
+/** Ag-grid style filter model of the active grid filters. */
+export declare function sirioToFilterModel(filters: SirioGridFilters, filterTypes?: SirioRemoteFilterTypes): SirioRemoteFilterModel;
+/** Any of the values (conditions in OR): for example the states chosen with chips. */
+export declare function sirioAnyOf(values: readonly (string | number)[]): SirioRemoteFilterModel;
 /** Duration of the kit collapse transition (`[data-sirio-visible=collapsing]`, .35s). */
 declare const SIRIO_COLLAPSE_MS = 350;
 /** Values of `data-sirio-visible` used by the kit collapsible elements. */
@@ -5144,6 +5304,8 @@ export declare const SIRIO_SIDENAV: readonly [typeof SirioSidenav, typeof SirioS
  * (`danger` = "Alert", `warning`, `info`, `success`).
  */
 export type SirioTagType = 'default' | 'danger' | 'warning' | 'info' | 'success';
+/** Size of the tag: `default` = the kit tag, `small` = compact (e.g. inside the rows of a grid). */
+export type SirioTagSize = 'default' | 'small';
 /**
  * Tag of the Sirio web kit ("Tag"), applied to a `<span>`: `span.sirio-tag` with the kit background
  * class of the type (`sirio-bg-danger`, `sirio-bg-warning`, `sirio-bg-info`, `sirio-bg-success`).
@@ -5151,10 +5313,14 @@ export type SirioTagType = 'default' | 'danger' | 'warning' | 'info' | 'success'
  * As the kit says, tags label the type of a content in one or two words (e.g. inside a Card) and
  * are **not interactive**: never use them instead of the input or selection chips.
  *
+ * `outline` draws the lighter variant (border and text in the color of the type, no background),
+ * for secondary information next to other tags; `size="small"` makes it compact.
+ *
  * ```html
  * <span wmSirioTag>Default</span>
  * <span wmSirioTag="success">Completato</span>
  * <span wmSirioTag background="primary-light-40">Novità</span>
+ * <span wmSirioTag="warning" outline size="small">Trace</span>
  * ```
  */
 export declare class SirioTag {
@@ -5162,9 +5328,13 @@ export declare class SirioTag {
   readonly type: import("@angular/core").InputSignalWithTransform<SirioTagType, "" | SirioTagType | null | undefined>;
   /**
    * Any other kit background (`sirio-bg-*` without the prefix, e.g. `warning-80`,
-   * `primary-light-40`); it replaces the color of the type.
+   * `primary-light-40`); it replaces the color of the type (and the outline).
    */
   readonly background: import("@angular/core").InputSignal<string | null>;
+  /** Outline variant: border and text in the color of the type, transparent background. */
+  readonly outline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Size: `default` (the kit tag) or `small` (compact). */
+  readonly size: import("@angular/core").InputSignalWithTransform<SirioTagSize, "" | SirioTagSize | null | undefined>;
   protected readonly classes: import("@angular/core").Signal<string>;
   static ɵfac: i0.ɵɵFactoryDeclaration<SirioTag, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SirioTag, "span[wmSirioTag]", never, {
@@ -5178,6 +5348,16 @@ export declare class SirioTag {
       "required": false;
       "isSignal": true;
     };
+    "outline": {
+      "alias": "outline";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, never, ["*"], true, never>;
 }
 /**
@@ -7009,7 +7189,7 @@ export declare class SirioTextbox extends SirioAdornedControlBase<string> {
   readonly type: import("@angular/core").InputSignal<SirioTextboxType>;
   readonly maxlength: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
   readonly autocomplete: import("@angular/core").InputSignal<string | null>;
-  /** When true, '' is propagated to the model as null. */
+  /** When true, '' is propagated to the model as null (always with `nullable`). */
   readonly emptyAsNull: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Casing applied to typed/pasted text. Values set from code (setValue/patchValue) are not changed. */
   readonly textCase: import("@angular/core").InputSignal<SirioTextCase>;
@@ -7056,6 +7236,8 @@ export declare class SirioTextarea extends SirioControlBase<string> {
   readonly rows: import("@angular/core").InputSignalWithTransform<number, unknown>;
   readonly maxlength: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
   readonly showCounter: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** When true, '' is propagated to the model as null. */
+  readonly emptyAsNull: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Casing applied to typed/pasted text. Values set from code (setValue/patchValue) are not changed. */
   readonly textCase: import("@angular/core").InputSignal<SirioTextCase>;
   /** Text alignment (null = Sirio default). */
@@ -7081,6 +7263,11 @@ export declare class SirioTextarea extends SirioControlBase<string> {
       "required": false;
       "isSignal": true;
     };
+    "emptyAsNull": {
+      "alias": "emptyAsNull";
+      "required": false;
+      "isSignal": true;
+    };
     "textCase": {
       "alias": "textCase";
       "required": false;
@@ -7410,6 +7597,13 @@ export declare abstract class SirioDateTimeBase extends SirioControlBase<string>
     };
   }, {}, never, never, true, never>;
 }
+/**
+ * Keyboard instructions of the date picker: `hint` when given (null or '' = none), otherwise the
+ * default text for the locale (Italian or English) and the pick level.
+ */
+export declare function sirioDatePickerKeyboardHint(hint: string | null | undefined, locale: string, level?: SirioDatePickLevel): string | null;
+/** Space separated ids for aria-describedby, skipping the empty ones (null when none). */
+export declare function sirioJoinIds(...ids: (string | null | undefined)[]): string | null;
 /**
  * Attaches the date picker of the Sirio web kit guide — **VanillaJS Datepicker**, styled by the kit
  * CSS (`css/datepicker.min.css` + the `.datepicker*` rules of `webkit.min.css`) — to an input
@@ -7462,6 +7656,13 @@ export declare class SirioDatePickerDirective implements OnDestroy {
   /** Back in its place after the input when the picker closes. */
   protected unfloat(): void;
   private create;
+  /**
+   * Picker options changed without touching the text. VanillaJS Datepicker `setOptions` always
+   * rewrites the field with its selected dates (`refreshUI(this, 3)`, bypassing the `refresh`
+   * override), and this effect may run before the one on `date`: when a limit changes together with
+   * the value, the field would show the previous date again (or lose the text being typed).
+   */
+  private setOptions;
   /** Aligns the picker selection with the component value, without touching the text. */
   private select;
   private isoOf;
@@ -7591,6 +7792,16 @@ export declare class SirioDate extends SirioDateTimeBase {
   readonly hideOnFocus: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** What is picked: a full date, a month (mm/aaaa) or a year (aaaa). */
   readonly pickLevel: import("@angular/core").InputSignal<SirioDatePickLevel>;
+  /**
+   * Keyboard instructions of the picker, read after the label (aria-describedby).
+   * Not set: default text for `LOCALE_ID` and the pick level; null or '' = none.
+   */
+  readonly keyboardHint: import("@angular/core").InputSignal<string | null | undefined>;
+  /** Instructions shown to screen readers (none when the picker cannot open). */
+  protected readonly keyboardHintText: import("@angular/core").Signal<string | null>;
+  protected readonly keyboardHintId: import("@angular/core").Signal<string>;
+  /** aria-describedby of the field: help and error first, then the keyboard instructions. */
+  protected readonly fieldDescribedBy: import("@angular/core").Signal<string | null>;
   /** Layout of the field for the pick level. */
   protected readonly layout: import("@angular/core").Signal<import("@wemake4u/form-controls").SirioDateTimeLayout>;
   protected readonly maxLength: import("@angular/core").Signal<number>;
@@ -7629,6 +7840,11 @@ export declare class SirioDate extends SirioDateTimeBase {
       "required": false;
       "isSignal": true;
     };
+    "keyboardHint": {
+      "alias": "keyboardHint";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, never, never, true, never>;
 }
 /**
@@ -7702,6 +7918,16 @@ export declare class SirioDateTime extends SirioDateTimeBase {
   readonly fieldLabels: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   /** Completes a missing part when the component is left: time 00:00 or today's date. */
   readonly completeParts: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Keyboard instructions of the date picker, read on the date field (aria-describedby).
+   * Not set: default text for `LOCALE_ID`; null or '' = none.
+   */
+  readonly keyboardHint: import("@angular/core").InputSignal<string | null | undefined>;
+  /** Instructions shown to screen readers (none when the picker cannot open). */
+  protected readonly keyboardHintText: import("@angular/core").Signal<string | null>;
+  protected readonly keyboardHintId: import("@angular/core").Signal<string>;
+  /** aria-describedby of the date field: help and error first, then the keyboard instructions. */
+  protected readonly dateDescribedBy: import("@angular/core").Signal<string | null>;
   private readonly host;
   private readonly dateFieldRef;
   protected readonly dateText: import("@angular/core").WritableSignal<string>;
@@ -7776,6 +8002,11 @@ export declare class SirioDateTime extends SirioDateTimeBase {
       "required": false;
       "isSignal": true;
     };
+    "keyboardHint": {
+      "alias": "keyboardHint";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, never, never, true, never>;
 }
 /**
@@ -7785,6 +8016,10 @@ export declare class SirioDateTime extends SirioDateTimeBase {
  * The label can contain markup: projected content is rendered inside the `<label>`, after the
  * `label` text (use inline elements only, such as `<span>`, `<strong>`, `<em>`, `<a>`).
  *
+ * With `nullable` the checkbox becomes a group of radio buttons (yes / no / no answer): the value is
+ * `true`, `false` or `null`. The labels are `trueLabel`, `falseLabel` and `nullOptionLabel`; the null option
+ * is not shown when the field is required. The label (text and projected content) names the group.
+ *
  * ```html
  * <wm-sirio-checkbox label="Accetto i termini" formControlName="privacy" />
  * <wm-sirio-checkbox label="Notifiche" toggle formControlName="notify" />
@@ -7797,8 +8032,29 @@ export declare class SirioCheckbox extends SirioControlBase<boolean> {
   /** Toggle position relative to the label. */
   readonly togglePosition: import("@angular/core").InputSignal<"left" | "right">;
   readonly inline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** nullable: label of the option with value true. */
+  readonly trueLabel: import("@angular/core").InputSignal<string>;
+  /** nullable: label of the option with value false. */
+  readonly falseLabel: import("@angular/core").InputSignal<string>;
+  /** nullable: label of the option with value null (not shown when the field is required). */
+  readonly nullOptionLabel: import("@angular/core").InputSignal<string>;
+  /** nullable: the options of the radio group. */
+  protected readonly nullableOptions: import("@angular/core").Signal<{
+    value: boolean | null;
+    label: string;
+    isNull: boolean;
+  }[]>;
+  /** nullable: native radio "name" (the name input or a generated unique one). */
+  protected get groupName(): string;
+  private readonly fallbackName;
+  /** nullable: a radio of the group was chosen. */
+  protected onChoose(value: boolean | null): void;
   protected onToggle(event: Event): void;
-  protected fromModel(value: unknown): boolean;
+  /**
+   * The value is a boolean. With nullable, null stays null (the null option is checked) and
+   * undefined checks no option (e.g. a property not passed, in wm-sirio-schema-form).
+   */
+  protected fromModel(value: unknown): boolean | null;
   static ɵfac: i0.ɵɵFactoryDeclaration<SirioCheckbox, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SirioCheckbox, "wm-sirio-checkbox", never, {
     "toggle": {
@@ -7816,6 +8072,21 @@ export declare class SirioCheckbox extends SirioControlBase<boolean> {
       "required": false;
       "isSignal": true;
     };
+    "trueLabel": {
+      "alias": "trueLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "falseLabel": {
+      "alias": "falseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nullOptionLabel": {
+      "alias": "nullOptionLabel";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, never, ["*"], true, never>;
 }
 /**
@@ -7897,6 +8168,9 @@ export declare class SirioChecklist<T = unknown> extends SirioControlBase<T[]> i
  * `chips` renders the options as Sirio selection chips ("Chips di selezione (Radio button)":
  * `.sirio-chip-selection` with the radio and its label), always on one row that wraps.
  *
+ * `nullable` adds a last option with value null (text `nullOptionLabel`, default "Nessuna scelta"), so the user
+ * can go back to no value; it is not shown when the field is required.
+ *
  * ```html
  * <wm-sirio-radio-group label="Sesso" [options]="[{ value: 'M', label: 'Maschio' }, { value: 'F', label: 'Femmina' }]"
  *                    inline formControlName="gender" />
@@ -7911,13 +8185,19 @@ export declare class SirioRadioGroup<T = unknown> extends SirioControlBase<T> {
   /** Renders the options as Sirio selection chips (`sirio-chip-selection`), on one row. */
   readonly chips: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
   readonly compareWith: import("@angular/core").InputSignal<SirioCompareWith<T>>;
+  /** nullable: label of the extra last option with value null. */
+  readonly nullOptionLabel: import("@angular/core").InputSignal<string>;
+  /** The extra option with value null, when `nullable` and the field is not required. */
+  protected readonly nullOption: import("@angular/core").Signal<SirioOption<T | null> | null>;
+  /** Options rendered: the bound options followed by the null option, if any. */
+  protected readonly displayedOptions: import("@angular/core").Signal<SirioOption<T | null>[]>;
   /** valueSync compares values (and array items) with `compareWith`. */
   protected sameItem(a: unknown, b: unknown): boolean;
   /** Native radio "name": uses the name input or a generated unique one. */
   protected get groupName(): string;
   private readonly fallbackName;
-  protected isChecked(option: SirioOption<T>): boolean;
-  protected select(option: SirioOption<T>): void;
+  protected isChecked(option: SirioOption<T | null>): boolean;
+  protected select(option: SirioOption<T | null>): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<SirioRadioGroup<any>, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SirioRadioGroup<any>, "wm-sirio-radio-group", never, {
     "options": {
@@ -7940,6 +8220,11 @@ export declare class SirioRadioGroup<T = unknown> extends SirioControlBase<T> {
       "required": false;
       "isSignal": true;
     };
+    "nullOptionLabel": {
+      "alias": "nullOptionLabel";
+      "required": false;
+      "isSignal": true;
+    };
   }, {}, ["optionLabel"], never, true, never>;
 }
 interface SelectItem<T> {
@@ -7992,6 +8277,9 @@ export declare const SIRIO_DEFAULT_SELECTION_SUMMARY: (count: number) => string;
  * valido") is shown. It runs again when the options change and ignores an empty options list
  * (options still loading).
  *
+ * With no options (and `loading` false) the open list shows a single disabled row with `noDataText`
+ * ("Nessun dato disponibile").
+ *
  * Multiple choice extras: `selectAll` adds a "Seleziona tutto" row at the top of the list (it selects or
  * deselects all the enabled options shown, the search results when searching); `maxVisibleSelections`
  * shows "n elementi selezionati" (`selectionSummary`) instead of the labels when more options are selected.
@@ -8009,6 +8297,8 @@ 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>;
+  /** Text of the row shown in the open list when there are no options (and they are not loading). */
+  readonly noDataText: 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.
@@ -8095,6 +8385,8 @@ export declare class SirioSelect<T = unknown> extends SirioControlBase<T | T[]>
   protected onSearchFocus(event: FocusEvent): void;
   protected onSearch(event: Event): void;
   /** Reset button: clears the search and the selection, as the Sirio autocomplete reset. */
+  /** nullable applies to the single select only (a multiple select is emptied by deselecting). */
+  protected isNullValue(value: T | T[] | null): boolean;
   protected reset(): void;
   protected choose(index: number): void;
   private emitSelected;
@@ -8138,6 +8430,11 @@ export declare class SirioSelect<T = unknown> extends SirioControlBase<T | T[]>
       "required": false;
       "isSignal": true;
     };
+    "noDataText": {
+      "alias": "noDataText";
+      "required": false;
+      "isSignal": true;
+    };
     "loading": {
       "alias": "loading";
       "required": false;
@@ -8734,6 +9031,415 @@ export declare class SirioFileUpload extends SirioControlBase<SirioFileItem[]> i
     "fileError": "fileError";
   }, never, never, true, never>;
 }
+/**
+ * The subset of JSON Schema (draft-07) understood by wm-sirio-schema-form. Other keywords are
+ * ignored; an empty schema (`{}`) accepts any JSON value.
+ */
+export interface SirioJsonSchema {
+  type?: string | string[];
+  format?: string;
+  title?: string;
+  description?: string;
+  enum?: unknown[];
+  properties?: Record<string, SirioJsonSchema>;
+  items?: SirioJsonSchema;
+  required?: string[];
+  pattern?: string;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  [keyword: string]: unknown;
+}
+/**
+ * How a list is edited: `objects` in a grid (a row per item), `chips` for allowed values (multiple
+ * choice), `tags` for texts and numbers typed one by one, `items` (a field per item) otherwise.
+ */
+export type SirioSchemaListKind = 'objects' | 'chips' | 'tags' | 'items';
+/** One segment of a value path: a property name or an array index. */
+export type SirioSchemaPathSegment = string | number;
+/** A problem of a value against its schema, at a path like `figli[0].nome` ('' is the root). */
+export interface SirioSchemaError {
+  path: string;
+  message: string;
+}
+/** Errors by path (`figli[0].nome`), e.g. the ones returned by a server validation. */
+export type SirioSchemaErrors = Record<string, string>;
+/** The kind of editor used for a schema: one per JSON type, `json` for anything else. */
+export type SirioSchemaEditor = 'object' | 'array' | 'text' | 'number' | 'integer' | 'boolean' | 'enum' | 'date' | 'datetime' | 'time' | 'json';
+/** The path as text: `a.b[0].c`. */
+export declare function sirioSchemaPath(segments: readonly SirioSchemaPathSegment[]): string;
+/**
+ * True when the schema admits null: a type list with `null` (`["string", "null"]`), the type `null`,
+ * an enum with null, or no type at all.
+ */
+export declare function sirioSchemaNullable(schema: SirioJsonSchema): boolean;
+/** The editor for a schema. */
+export declare function sirioSchemaEditor(schema: SirioJsonSchema): SirioSchemaEditor;
+/** How the list of the schema (an `array` with `items`) is edited. */
+export declare function sirioSchemaListKind(schema: SirioJsonSchema): SirioSchemaListKind;
+/** The problem of a list as a whole (`minItems`, `maxItems`, `uniqueItems`), or null. */
+export declare function sirioSchemaCheckList(schema: SirioJsonSchema, list: unknown): string | null;
+/** A short label of the type:`string`, `date`, `number`, `lista`, `valori ammessi`, `qualsiasi`... */
+export declare function sirioSchemaTypeLabel(schema: SirioJsonSchema): string;
+/** Every property of the schema with `null` (lists empty): the shape of the value, to fill in. */
+export declare function sirioSchemaSkeleton(schema: SirioJsonSchema): unknown;
+/** A plausible value for every property (lists with one item); a `pattern` is not followed. */
+export declare function sirioSchemaSample(schema: SirioJsonSchema, today?: Date): unknown;
+/** Adds the properties of the schema missing from the value (with `null`), keeping the others. */
+export declare function sirioSchemaComplete(schema: SirioJsonSchema, value: unknown): unknown;
+/** The paths of the value that the schema does not know (e.g. fields removed in a new version). */
+export declare function sirioSchemaUnknownPaths(schema: SirioJsonSchema, value: unknown): string[];
+/** The problem of a single (non object, non array) value, or null. `null` is accepted. */
+export declare function sirioSchemaCheck(schema: SirioJsonSchema, value: unknown): string | null;
+/** The problems of a value against the schema (missing properties are not problems). */
+export declare function sirioSchemaValidate(schema: SirioJsonSchema, value: unknown): SirioSchemaError[];
+/** The value at a path. */
+export declare function sirioSchemaGet(value: unknown, path: readonly SirioSchemaPathSegment[]): unknown;
+/**
+ * A copy of the value with `item` at the path (`undefined` removes the property); the objects
+ * left empty by a removal are removed too.
+ */
+export declare function sirioSchemaSet(value: unknown, path: readonly SirioSchemaPathSegment[], item: unknown): unknown;
+/** The kinds of field of wm-sirio-schema-form (`json`: a value without type; `chips`: a list of allowed values). */
+export type SirioSchemaFieldKind = SirioSchemaEditor | 'chips';
+/**
+ * What a field editor of its own receives (in the `field` input of a component, or as the
+ * implicit value of a `wmSirioSchemaField` template). The form keeps the value: the editor only
+ * reads and writes `control` (for `json` fields the text, read as JSON by the form).
+ */
+export interface SirioSchemaFieldContext {
+  /** The control of the field. */
+  control: FormControl<unknown>;
+  kind: SirioSchemaFieldKind;
+  /** The part of the schema of this field. */
+  schema: SirioJsonSchema;
+  /** The property name (`nome`, `figli[0]` for a list item). */
+  name: string;
+  /** The path in the value (`figli[0].nome`). */
+  path: string;
+  /** Id for the input element: the label of the field points to it. */
+  inputId: string;
+  /** Ids of the help text and of the error message, for aria-describedby. */
+  describedBy: string;
+  /** Short field, without label and help (grid cell). */
+  compact: boolean;
+  readonly: boolean;
+  disabled: boolean;
+}
+/** The components that edit the fields of a kind, in place of the Sirio control of the form. */
+export type SirioSchemaFieldEditors = Partial<Record<SirioSchemaFieldKind, Type<unknown>>>;
+/** The field editors of the application (see provideSirioSchemaFieldEditors). */
+export declare const SIRIO_SCHEMA_FIELD_EDITORS: InjectionToken<Partial<Record<SirioSchemaFieldKind, Type<unknown>>>>;
+/**
+ * Field editors of their own for every wm-sirio-schema-form, by kind of field: each component
+ * gets the SirioSchemaFieldContext in its `field` input. The label, the help text and the error
+ * message stay the form's (Sirio field).
+ *
+ * ```ts
+ * providers: [provideSirioSchemaFieldEditors({ json: MyJsonFieldComponent })]
+ * ```
+ */
+export declare function provideSirioSchemaFieldEditors(editors: SirioSchemaFieldEditors): Provider;
+/**
+ * A field editor for one form, by kind of field (it wins over provideSirioSchemaFieldEditors):
+ *
+ * ```html
+ * <wm-sirio-schema-form [schema]="schema" [(ngModel)]="value">
+ *   <ng-template wmSirioSchemaField="json" let-field>
+ *     <my-json-editor [formControl]="field.control" [attr.aria-describedby]="field.describedBy" />
+ *   </ng-template>
+ * </wm-sirio-schema-form>
+ * ```
+ */
+export declare class SirioSchemaFieldTemplate {
+  readonly kind: import("@angular/core").InputSignal<SirioSchemaFieldKind>;
+  readonly template: TemplateRef<{
+    $implicit: SirioSchemaFieldContext;
+  }>;
+  static ngTemplateContextGuard(_dir: SirioSchemaFieldTemplate, ctx: unknown): ctx is {
+    $implicit: SirioSchemaFieldContext;
+  };
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioSchemaFieldTemplate, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SirioSchemaFieldTemplate, "ng-template[wmSirioSchemaField]", never, {
+    "kind": {
+      "alias": "wmSirioSchemaField";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+interface SchemaNodeBase {
+  /** Property name, or `name[i]` for a list item. */
+  name: string;
+  path: string;
+  segments: SirioSchemaPathSegment[];
+  schema: SirioJsonSchema;
+  /** Nesting level of the groups: 0 for the properties of the root. */
+  depth: number;
+}
+/** An object: a group that opens and closes, with its properties. */
+export interface SirioSchemaObjectNode extends SchemaNodeBase {
+  kind: 'object';
+  children: SirioSchemaNode[];
+}
+/**
+ * A list. `objects`: a grid with a row per item (the simple properties in the cells, the others
+ * in the row detail); `tags`: texts or numbers typed one by one; `items`: a field per item.
+ * Lists of allowed values are fields (`chips` editor).
+ */
+export interface SirioSchemaArrayNode extends SchemaNodeBase {
+  kind: 'array';
+  list: Exclude<SirioSchemaListKind, 'chips'>;
+  items: SirioSchemaNode[];
+  /** `objects`: the properties shown in the grid cells. */
+  columns: string[];
+  /** `objects`: some properties are not in the cells, so the rows open a detail with them. */
+  hasDetail: boolean;
+}
+/** A field, edited by a Sirio control bound to its own FormControl. */
+export interface SirioSchemaFieldNode extends SchemaNodeBase {
+  kind: 'field';
+  editor: SirioSchemaEditor | 'chips';
+  control: FormControl<unknown>;
+  options: SirioOption<unknown>[];
+  /** The schema admits null: the Sirio control is `nullable` (its "X" sets the property to null). */
+  nullable: boolean;
+}
+export type SirioSchemaNode = SirioSchemaObjectNode | SirioSchemaArrayNode | SirioSchemaFieldNode;
+/** How many fields of the form have a value. */
+export interface SirioSchemaFormSummary {
+  filled: number;
+  total: number;
+}
+/**
+ * Form generated from a JSON Schema (draft-07 subset, see `SirioJsonSchema`): one Sirio control per
+ * property (textbox, number, date, datetime, time, select for `enum`, Sì/No/null for booleans,
+ * JSON textarea for untyped values).
+ *
+ * Objects are groups that open and close (`expandDepth`, `expandAll()`, `collapseAll()`): the
+ * header shows how many fields are filled, the state (not passed, `null`, `{ }`) and the errors,
+ * and a menu fills the group with sample values or empty fields, sets it to `null`, removes it
+ * or copies its JSON. Lists of objects are grids (simple properties in the cells, the others in
+ * the row detail) with duplicate / move / remove per row; lists of allowed values are selection
+ * chips; lists of texts or numbers are tags typed one by one. `minItems`, `maxItems` and
+ * `uniqueItems` are checked.
+ *
+ * The model is the JSON value. A property is in the value only when it has one: an empty field,
+ * or one cleared with its ✕ button, is not passed (that is different from `null`).
+ *
+ * Validation: each field checks its schema; `errors` adds errors from outside (e.g. a server
+ * validation) by path (`figli[0].nome`), shown on the field, group or list until it is changed;
+ * the groups with errors open. Errors on unknown paths are listed above the form. As a validator
+ * the form returns `{ sirioSchema: SirioSchemaError[] }`.
+ *
+ * The control of a kind of field can be replaced by an editor of its own (e.g. a JSON editor for
+ * the `json` fields), for the whole application with `provideSirioSchemaFieldEditors` or for one
+ * form with `<ng-template wmSirioSchemaField="json" let-field>`: it gets the
+ * SirioSchemaFieldContext, while label, help and message stay the form's.
+ *
+ * ```html
+ * <wm-sirio-schema-form [schema]="schema" [errors]="serverErrors" [(ngModel)]="input" />
+ * ```
+ */
+export declare class SirioSchemaForm extends SirioControlBase<unknown> implements Validator {
+  /** The JSON Schema of the value. */
+  readonly schema: import("@angular/core").InputSignal<SirioJsonSchema>;
+  /** Errors from outside by path (`figli[0].nome`; '' is the whole value). */
+  readonly errors: import("@angular/core").InputSignal<SirioSchemaErrors | null>;
+  /** Shows the type (and the description) of each field below it. */
+  readonly showTypes: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Groups open at the start: those up to this nesting level (0 = all closed). */
+  readonly expandDepth: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Properties of a list item shown in the grid cells (the others are in the row detail). */
+  readonly maxColumns: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly clearLabel: import("@angular/core").InputSignal<string>;
+  readonly addLabel: import("@angular/core").InputSignal<string>;
+  readonly removeLabel: import("@angular/core").InputSignal<string>;
+  readonly emptyListText: import("@angular/core").InputSignal<string>;
+  readonly tagPlaceholder: import("@angular/core").InputSignal<string>;
+  private readonly host;
+  private readonly renderInjector;
+  /** The fields' FormControls by path, with the subscription to their changes. */
+  private readonly fields;
+  private fieldsSchema;
+  /** The text being typed in the tag lists, by path. */
+  private readonly drafts;
+  /** Changes when fields are dropped to be created again (e.g. items moved): the tree is built anew. */
+  private readonly rebuild;
+  /** Errors from `errors` still shown: an error goes away when its field, group or list changes. */
+  private readonly pendingErrors;
+  /** Groups opened or closed by the user (the others follow `expandDepth`). */
+  private readonly openGroups;
+  /** Grid rows with the detail open, by item path. */
+  protected readonly expandedRows: import("@angular/core").WritableSignal<Record<string, boolean>>;
+  protected readonly messages: SirioErrorMessages;
+  /** The application's field editors (provideSirioSchemaFieldEditors). */
+  private readonly fieldEditors;
+  /** The field editors of this form (`<ng-template wmSirioSchemaField="json">`): they win. */
+  private readonly fieldTemplates;
+  /** Changes with the state of the fields' controls (value, validity, touched): their errors are shown again. */
+  private readonly fieldState;
+  private readonly fieldIds;
+  /** The editor of its own for the kind of a field, if any. */
+  protected customEditor(node: SirioSchemaFieldNode): {
+    template?: TemplateRef<unknown>;
+    component?: Type<unknown>;
+  } | null;
+  /** The ids of a field (input, help, error): stable for its path. */
+  protected fieldId(node: SirioSchemaFieldNode): string;
+  private readonly contexts;
+  /** What an editor of its own gets: the same object while the field and its state do not change. */
+  protected fieldContext(node: SirioSchemaFieldNode, compact: boolean): SirioSchemaFieldContext;
+  /** The message of a field with an editor of its own: shown once it was touched or changed. */
+  protected customError(node: SirioSchemaFieldNode): string | null;
+  private onValidatorChange;
+  constructor();
+  /** The lengths of the lists in the value: the tree changes only with them (and the schema). */
+  private readonly shape;
+  /** The nodes of the form (the properties of the root object). */
+  protected readonly tree: import("@angular/core").Signal<SirioSchemaNode[]>;
+  /** Every node by path. */
+  private readonly nodes;
+  private readonly fieldNodes;
+  /** Filled and total fields (an empty list counts as one empty field). */
+  readonly summary: import("@angular/core").Signal<SirioSchemaFormSummary>;
+  /** The paths with an error: from `errors` (until changed) and from the schema. */
+  private readonly errorPaths;
+  /** The external errors that are not on a field, group or list (e.g. on an unknown property). */
+  protected readonly otherErrors: import("@angular/core").Signal<SirioSchemaError[]>;
+  private node;
+  private field;
+  private dropFields;
+  /** Forgets the external errors of a path and of what it contains (its items, its fields). */
+  private forgetError;
+  /** The external error of a path, or the first one of its items (`[1]: ...`). */
+  private itemsError;
+  private count;
+  /**
+   * The value of the JSON as the control's model. Not passed is an empty control (null), except for
+   * a boolean that admits null: undefined, so that no option is checked (null checks "null").
+   */
+  private toField;
+  /**
+   * The control's model as the value of the JSON (`undefined`: not passed). An empty control is
+   * null when the schema admits it (`nullable` controls: the "X" or an emptied text), not passed
+   * otherwise.
+   */
+  private fromField;
+  private sameField;
+  private validateField;
+  protected isOpen(node: SirioSchemaNode): boolean;
+  protected setOpen(path: string, open: boolean): void;
+  /** Opens every group and list. */
+  expandAll(): void;
+  /** Closes every group and list. */
+  collapseAll(): void;
+  private setAllGroups;
+  /** Opens the groups and the grid rows that contain the paths. */
+  private reveal;
+  /** `n di m compilati` for an object, `n elementi` for a list. */
+  protected groupSummary(node: SirioSchemaObjectNode | SirioSchemaArrayNode): string;
+  /** The state of a group when it has no fields to show: not passed, `null`, `{ }`, `[ ]`. */
+  protected stateLabel(node: SirioSchemaNode): string;
+  protected errorCount(path: string): number;
+  /** The error of the group or list itself (from `errors`, or `minItems` / `maxItems` / `uniqueItems`). */
+  protected groupError(node: SirioSchemaNode): string | null;
+  /** The menu of a group, kept while the group and its state do not change. */
+  private readonly menus;
+  protected menu(path: string): SirioDropdownItem[];
+  protected onGroupAction(node: SirioSchemaObjectNode | SirioSchemaArrayNode, action: unknown): void;
+  /** Replaces the value of a group or list (its fields are created again). */
+  private replace;
+  protected addItem(node: SirioSchemaArrayNode): void;
+  protected removeItem(node: SirioSchemaArrayNode, index: number): void;
+  protected onRowAction(node: SirioSchemaArrayNode, item: SirioSchemaNode, action: unknown): void;
+  /** A new list: the items move, so their fields and open rows start again. */
+  private replaceList;
+  private listOf;
+  protected setExpandedRows(expanded: SirioGridExpanded): void;
+  /** The properties of a list item not shown in the grid cells. */
+  protected detailNodes(list: SirioSchemaArrayNode, item: SirioSchemaNode): SirioSchemaNode[];
+  protected cellNode(item: SirioSchemaNode, column: string): SirioSchemaNode | null;
+  /** The width of a grid column, enough for its editor. */
+  protected columnWidth(node: SirioSchemaArrayNode, column: string): string;
+  protected readonly noDetail: () => boolean;
+  protected readonly rowClass: (item: SirioSchemaNode) => "" | "wm-schema-row-invalid";
+  protected draft(node: SirioSchemaArrayNode): FormControl<string | null>;
+  protected tags(node: SirioSchemaArrayNode): unknown[];
+  protected isRepeated(node: SirioSchemaArrayNode, index: number): boolean;
+  protected addTag(node: SirioSchemaArrayNode, event: Event): void;
+  /** Backspace in the empty field removes the last tag. */
+  protected removeLastTag(node: SirioSchemaArrayNode): void;
+  protected tagsHint(node: SirioSchemaArrayNode): string;
+  protected isSet(node: SirioSchemaNode): boolean;
+  /** Below the field: the type, `null` when the value is null, the description. */
+  protected hint(node: SirioSchemaFieldNode): string;
+  protected clear(node: SirioSchemaNode): void;
+  protected index(node: SirioSchemaNode): number;
+  /** Brings the field at the path (or its closest group) into view and focuses it. */
+  focusPath(path: string): void;
+  protected fromModel(value: unknown): unknown;
+  protected hasValue(value: unknown): boolean;
+  validate(control: AbstractControl): ValidationErrors | null;
+  registerOnValidatorChange(fn: () => void): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SirioSchemaForm, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SirioSchemaForm, "wm-sirio-schema-form", never, {
+    "schema": {
+      "alias": "schema";
+      "required": true;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "showTypes": {
+      "alias": "showTypes";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandDepth": {
+      "alias": "expandDepth";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxColumns": {
+      "alias": "maxColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "clearLabel": {
+      "alias": "clearLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "addLabel": {
+      "alias": "addLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLabel": {
+      "alias": "removeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyListText": {
+      "alias": "emptyListText";
+      "required": false;
+      "isSignal": true;
+    };
+    "tagPlaceholder": {
+      "alias": "tagPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["fieldTemplates"], never, true, never>;
+}
 /** All Sirio data-entry controls, buttons and helper directives, for `imports: [SIRIO_FORM_CONTROLS]`. */
-export declare const SIRIO_FORM_CONTROLS: readonly [typeof SirioTextbox, typeof SirioTextarea, typeof SirioNumber, typeof SirioDate, typeof SirioTime, typeof SirioDateTime, typeof SirioCheckbox, typeof SirioChecklist, typeof SirioRadioGroup, typeof SirioSelect, typeof SirioAutocomplete, typeof SirioSearchbar, typeof SirioSlider, typeof SirioFileUpload, typeof SirioButton, typeof SirioPrefix, typeof SirioSuffix, typeof SirioOptionLabel];
+export declare const SIRIO_FORM_CONTROLS: readonly [typeof SirioTextbox, typeof SirioTextarea, typeof SirioNumber, typeof SirioDate, typeof SirioTime, typeof SirioDateTime, typeof SirioCheckbox, typeof SirioChecklist, typeof SirioRadioGroup, typeof SirioSelect, typeof SirioAutocomplete, typeof SirioSearchbar, typeof SirioSlider, typeof SirioFileUpload, typeof SirioSchemaForm, typeof SirioSchemaFieldTemplate, typeof SirioButton, typeof SirioPrefix, typeof SirioSuffix, typeof SirioOptionLabel];
 export {};