@starterlib/ui 0.8.0 → 0.9.1

package/types/starterlib-ui-saisie.d.ts

@@ -1,9 +1,8 @@
-import { DateIso, PlageDeDates, DescriptionDeFichier } from '@starterlib/util';
-import { ValidationError, FormValueControl, FormCheckboxControl } from '@angular/forms/signals';
-import * as _starterlib_ui from '@starterlib/ui';
-import { LibellesUi, AnnonceLocale } from '@starterlib/ui';
-import * as _angular_core from '@angular/core';
-
+import { Adresse, DateIso, DescriptionDeFichier, FormatDAdresse, HeureIso, NatureDeRegion, PartieDAdresse, PlageDeDates, sansCommandesDeDirection } from "@starterlib/util";
+import { DisabledReason, FormCheckboxControl, FormValueControl, ValidationError, WithOptionalFieldTree } from "@angular/forms/signals";
+import { AnnonceLocale, EtiquetteDeGroupe, Icone, LibellesUi } from "@starterlib/ui";
+import * as i0 from "@angular/core";
+import { InjectionToken, Signal } from "@angular/core";
 /**
  * Forme minimale d'une erreur de validation, telle que Signal Forms la rend :
  * un genre, et parfois un message.
@@ -12,9 +11,45 @@ import * as _angular_core from '@angular/core';
  * vague 3, V3-1). Les proprietes propres a chaque genre — `minLength`, `max`… —
  * se lisent par leur nom.
  */
-interface ErreurAffichable {
-    readonly kind: string;
-    readonly message?: string;
+export interface ErreurAffichable {
+  readonly kind: string;
+  readonly message?: string;
+}
+/** Erreur de longueur : `minLength`, `maxLength`, et `longueur` (les deux bornes, du serveur). */
+export interface ErreurDeLongueur extends ErreurAffichable {
+  readonly kind: 'minLength' | 'maxLength' | 'longueur';
+  readonly minLength?: number;
+  readonly maxLength?: number;
+}
+/**
+ * Erreur de borne : un nombre (`min`, `max`), une date ISO (`dateMin`, `dateMax`) ou une heure
+ * ISO (`heureMin`, `heureMax`) ; `DateIso` et `HeureIso` sont deux chaines.
+ */
+export interface ErreurDeBorne extends ErreurAffichable {
+  readonly kind: 'min' | 'max' | 'dateMin' | 'dateMax' | 'heureMin' | 'heureMax';
+  readonly min?: number | DateIso;
+  readonly max?: number | DateIso;
+  /** Borne EXCLUSIVE du serveur (`@DecimalMin(inclusive = false)`) : dite strictement (lot 201). */
+  readonly strict?: boolean;
+}
+/** Erreur d'un fichier ou d'une liste de fichiers : lequel, et la limite franchie. */
+export interface ErreurDeFichier extends ErreurAffichable {
+  readonly kind: 'fichierTaille' | 'fichierType' | 'fichiersNombre';
+  readonly fichier?: string;
+  /** En octets pour `fichierTaille`, en nombre de fichiers pour `fichiersNombre`. */
+  readonly max?: number;
+}
+/**
+ * Erreur d'une adresse, sur une PARTIE (cle `partie`, comme `st-date-range`) : `adresse` pour une
+ * partie exigee restee vide, `codePostal` pour un code qui n'a pas la forme du pays (avec un
+ * exemple reel), `pays` pour un pays hors de la liste admise.
+ */
+export interface ErreurDAdresse extends ErreurAffichable {
+  readonly kind: 'adresse' | 'codePostal' | 'pays';
+  readonly partie: PartieDAdresse;
+  /** Ce que la region designe dans le pays : le message la nomme comme le champ. */
+  readonly nature?: NatureDeRegion;
+  readonly exemple?: string;
 }
 /**
  * Le texte d'une erreur, dans la langue courante.
@@ -27,17 +62,30 @@ interface ErreurAffichable {
  * Afficher `ibanChecksum` a une personne qui saisit un IBAN, c'est lui montrer le
  * code source.
  *
- * La locale sert aux messages qui citent un format, une date ou une taille : « au
- * format jj/mm/aaaa » n'est pas « mm/dd/yyyy ».
+ * La locale sert aux messages qui citent un format, une date, une taille ou un nombre : « au
+ * format jj/mm/aaaa » n'est pas « mm/dd/yyyy », et « 1 000,5 » n'est pas « 1,000.5 ». Les
+ * composants la lisent dans `ST_LOCALE`.
+ *
+ * ⚠️ **Un parametre malforme rend le message generique, il ne leve jamais** : l'appel vit dans
+ * un `computed` du champ, et une exception y viderait le champ, voire la page (constat A1132). Une
+ * date qui n'est pas ISO, une devise qui n'est pas un code de trois lettres : « valeur invalide ».
+ *
+ * `minLength` et `maxLength` sur une LISTE (les options cochees d'un `st-checkbox-group`, lot 248)
+ * comptent des options : « Choisissez au moins 1 option. », et non « Saisissez au moins
+ * 1 caracteres. ».
  */
-declare function messageDErreur(erreur: ErreurAffichable, libelles: LibellesUi, locale?: string): string;
+export declare function messageDErreur(erreur: ErreurAffichable, libelles: LibellesUi, locale?: string): string;
+/** Le libelle d'une partie d'adresse, tel que le champ l'affiche. */
+export declare function libelleDePartie(libelles: LibellesUi, partie: string, nature?: string): string;
 /** Le motif a taper dans la langue courante : `jj/mm/aaaa`. */
-declare function motifLocal(libelles: LibellesUi, locale: string): string;
+export declare function motifLocal(libelles: LibellesUi, locale: string): string;
+/** Le motif d'une heure dans la langue courante : `hh:mm`, `hh:mm AM/PM`. */
+export declare function motifDHeureLocal(libelles: LibellesUi, locale: string, secondes?: boolean): string;
 /**
  * Un jour superieur a 12 : « 31/03/2026 » montre sans ambiguite ou va le jour,
  * ce que « 01/02/2026 » ne dit pas.
  */
-declare function exempleDeDate(locale: string): string;
+export declare function exempleDeDate(locale: string): string;
 /**
  * Erreur d'IBAN, a brancher sur un schema :
  *
@@ -53,23 +101,40 @@ declare function exempleDeDate(locale: string): string;
  * vide n'est pas « invalide » ici — c'est `required` qui le dit, avec le bon
  * message.
  */
-declare function erreurIban(valeur: string): ErreurAffichable | null;
+export declare function erreurIban(valeur: string): ErreurAffichable | null;
 /**
- * Erreur de FORME d'un numero de telephone : chiffres, `+` de tete facultatif,
- * de 4 a 15 chiffres — la longueur maximale d'un numero international (E.164).
+ * Erreur de FORME d'un numero de telephone : chiffres et separateurs usuels (espace, point,
+ * tiret, parentheses), `+` de tete facultatif, de 4 a 15 chiffres — la longueur maximale d'un
+ * numero international (E.164).
  *
  * ```ts
  * validate(chemin.telephone, ({ value }) => erreurTelephone(value()));
  * ```
  *
+ * ⚠️ La forme se juge sur le texte RECU : « 06 12 AB » est refuse, meme si `normaliserTelephone`
+ * en tire « 0612 ». `st-phone-field` le signale aussi sur sa saisie, dont le modele ne garde que
+ * les chiffres et le `+` de tete.
+ *
  * ⚠️ Une forme valide ne dit pas que le numero existe : seul le serveur le sait.
  * Un champ vide n'est pas une erreur de forme : l'obligation est une autre regle.
  */
-declare function erreurTelephone(valeur: string): ErreurAffichable | null;
+export declare function erreurTelephone(valeur: string): ErreurAffichable | null;
+/**
+ * Erreur d'un code a usage unique : exactement `longueur` chiffres (6 par defaut), rien d'autre.
+ *
+ * ```ts
+ * validate(chemin.code, ({ value }) => erreurCode(value(), 6));
+ * ```
+ *
+ * ⚠️ Vide, le code n'est pas « incomplet » : l'obligation est une autre regle, avec son message.
+ * Le message dit la longueur attendue (« Saisissez les 6 chiffres du code. ») et non « invalide » :
+ * un code refuse par le serveur (« Code incorrect. ») arrive par `errors`, avec son propre texte.
+ */
+export declare function erreurCode(valeur: string, longueur?: number): ErreurAffichable | null;
 /** Bornes d'une date, en ISO. Absente : pas de borne. */
-interface BornesDeDate {
-    readonly min?: DateIso | null;
-    readonly max?: DateIso | null;
+export interface BornesDeDate {
+  readonly min?: DateIso | null;
+  readonly max?: DateIso | null;
 }
 /**
  * Erreur de bornes d'une date, a brancher sur un schema :
@@ -81,16 +146,59 @@ interface BornesDeDate {
  * Les bornes du schema et celles passees au calendrier doivent etre les memes :
  * le calendrier grise, le schema refuse une date tapee a la main.
  */
-declare function erreurDate(valeur: DateIso | null, bornes: BornesDeDate): ErreurAffichable | null;
+export declare function erreurDate(valeur: DateIso | null, bornes: BornesDeDate): ErreurDeBorne | null;
+/** Bornes d'une heure, `HH:MM` ou `HH:MM:SS`. Absente : pas de borne. */
+export interface BornesDHeure {
+  readonly min?: HeureIso | null;
+  readonly max?: HeureIso | null;
+}
+/**
+ * Erreur de bornes d'une heure, a brancher sur un schema, comme `erreurDate` :
+ *
+ * ```ts
+ * validate(chemin.execution, ({ value }) => erreurHeure(value(), { min: '08:00', max: '18:00' }));
+ * ```
+ *
+ * Les bornes du schema et celles passees au champ (`heureMin`, `heureMax`, dites dans l'aide)
+ * doivent etre les memes. Une heure absente n'est pas hors bornes : c'est `required` qui le dit.
+ */
+export declare function erreurHeure(valeur: HeureIso | null, bornes: BornesDHeure): ErreurDeBorne | null;
 /** Une fin anterieure au debut. Une borne manquante n'est pas une erreur de plage. */
-declare function erreurPlageDeDates(plage: PlageDeDates): ErreurAffichable | null;
+export declare function erreurPlageDeDates(plage: PlageDeDates): ErreurAffichable | null;
+/** Regles d'une adresse, les memes que les entrees de `st-address-fieldset`. */
+export interface ReglesDAdresse {
+  /** Faux : une adresse vide est admise ; une adresse commencee doit quand meme etre complete. */
+  readonly requise?: boolean;
+  /** Les pays admis (codes ISO) ; absent : tous. */
+  readonly codesDesPays?: readonly string[];
+}
+/**
+ * Erreurs d'une adresse, une par partie a corriger, dans l'ordre du champ (le pays d'abord) :
+ *
+ * ```ts
+ * required(chemin.adresse); // la mention « obligatoire » et aria-required
+ * validate(chemin.adresse, ({ value }) => erreursDAdresse(value()));
+ * ```
+ *
+ * ⚠️ `required` seul ne suffit pas : une adresse est un objet, jamais « vide » pour Signal Forms.
+ * Ce sont ces erreurs qui bloquent l'envoi. Les parties exigees suivent le format du pays
+ * (`partiesExigees`) : la province au Canada, rien de tel en France.
+ *
+ * ⚠️ Confort de saisie (SEC-5) : le serveur revalide ; le motif d'un code postal n'est qu'une forme.
+ */
+export declare function erreursDAdresse(adresse: Adresse, regles?: ReglesDAdresse): ErreurDAdresse[];
+/**
+ * Un pays hors de la liste admise (`st-country-field` avec `codes`) : la valeur deja dans le
+ * modele reste affichee, et cette erreur dit pourquoi elle ne passe pas.
+ */
+export declare function erreurPays(code: string, codesAdmis: readonly string[]): ErreurAffichable | null;
 /** Regles de `st-file-upload`, les memes que ses entrees. */
-interface ReglesDeFichiers {
-    /** Attribut `accept` : `.pdf, image/*`. */
-    readonly accept?: string;
-    /** En octets. */
-    readonly tailleMax?: number;
-    readonly nombreMax?: number;
+export interface ReglesDeFichiers {
+  /** Attribut `accept` : `.pdf, image/*`. */
+  readonly accept?: string;
+  /** En octets. */
+  readonly tailleMax?: number;
+  readonly nombreMax?: number;
 }
 /**
  * Erreurs d'une liste de fichiers, une par fichier refuse, pour dire LEQUEL :
@@ -102,7 +210,7 @@ interface ReglesDeFichiers {
  * ⚠️ Confort, jamais securite (SEC-5) : le type se deduit de l'extension, et le
  * serveur relit le contenu.
  */
-declare function erreursDeFichiers(fichiers: readonly DescriptionDeFichier[], regles: ReglesDeFichiers): ErreurAffichable[];
+export declare function erreursDeFichiers(fichiers: readonly DescriptionDeFichier[], regles: ReglesDeFichiers): ErreurDeFichier[];
 /**
  * Erreurs a afficher par un champ qui LIT sa saisie (`transformedValue`) : celles
  * du formulaire, plus les erreurs de lecture qu'il ne connait pas encore.
@@ -112,54 +220,361 @@ declare function erreursDeFichiers(fichiers: readonly DescriptionDeFichier[], re
  * sans cette fusion, « 12,5,3 » s'afficherait sans le moindre message. Une erreur
  * deja presente — meme genre, meme partie — n'est pas repetee.
  */
-declare function fusionnerErreurs(formulaire: readonly ValidationError.WithOptionalFieldTree[], lecture: readonly ValidationError.WithoutFieldTree[]): readonly ErreurAffichable[];
-
+export declare function fusionnerErreurs(formulaire: readonly ValidationError.WithOptionalFieldTree[], lecture: readonly ValidationError.WithoutFieldTree[]): readonly ErreurAffichable[];
 /** Elements natifs qui portent la saisie d'un champ du socle. */
-type ElementDeSaisie = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+export type ElementDeSaisie = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
 /**
  * Base des champs du socle : le contrat Signal Forms, ecrit une fois — tout sauf
- * `value`, dont le type depend du champ (texte, montant, date).
+ * `value` (ou `checked`), dont le type depend du champ (texte, montant, date, case).
  *
- * ⚠️ **Une base, et non une copie par champ.** Neuf membres de contrat recopies
- * dans six composants, c'est six occasions d'en oublier un — et l'oubli ne se
- * voit pas : un champ sans `touched` n'affiche jamais ses erreurs, un champ sans
- * reflet de `hidden` ne se masque pas, et rien n'echoue.
+ * ⚠️ **Une base, et non une copie par champ.** Seize membres de contrat recopies
+ * dans dix-sept composants, c'est dix-sept occasions d'en oublier un — et l'oubli ne se
+ * voit pas : [formField] ne pose que les entrees DECLAREES, sans erreur pour les autres. Un
+ * champ sans `touched` n'affiche jamais ses erreurs, un champ sans `readonly` reste modifiable
+ * sous une regle `readonly()` du schema, un champ sans reflet de `hidden` ne se masque pas.
+ *
+ * Les bornes de VALEUR (`min`, `max`) sont a part, dans `ContratDeChampABornes` : Signal Forms
+ * les type par la valeur du champ, et une borne mal typee casse la liaison `[formField]`.
  *
  * Les noms restent anglais : voir le glossaire, § 8.
  *
  * Le gabarit du champ doit nommer son element natif `#champ`, et le brancher sur
  * `touch` a la perte du focus.
  */
-declare abstract class ContratDeChamp {
-    readonly libelle: _angular_core.InputSignal<string>;
-    readonly aide: _angular_core.InputSignal<string | null>;
-    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly name: _angular_core.InputSignal<string>;
-    readonly touch: _angular_core.OutputEmitterRef<void>;
-    private readonly champ;
-    /** Appele par Signal Forms pour amener le focus sur un champ en erreur. */
-    focus(options?: FocusOptions): void;
-    protected texteSaisi(evenement: Event): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContratDeChamp, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ContratDeChamp, never, never, { "libelle": { "alias": "libelle"; "required": true; "isSignal": true; }; "aide": { "alias": "aide"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "touch": "touch"; }, never, never, true, never>;
+export declare abstract class ContratDeChamp {
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Une validation asynchrone est en cours (« Verification… »). */
+  readonly pending: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Pourquoi le champ est desactive : a dire en aide, jamais a taire. */
+  readonly disabledReasons: import("@angular/core").InputSignal<readonly WithOptionalFieldTree<DisabledReason>[]>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly minLength: import("@angular/core").InputSignal<number | undefined>;
+  readonly maxLength: import("@angular/core").InputSignal<number | undefined>;
+  readonly pattern: import("@angular/core").InputSignal<readonly RegExp[]>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly champ;
+  /** Le groupe (`st-fieldset`) qui contient le champ, s'il y en a un. */
+  private readonly groupe;
+  /**
+   * Desactive par le schema OU par son groupe. ⚠️ `fieldset[disabled]` natif ne gele que les
+   * elements natifs : un controle NON natif (declencheur `div role=combobox`) lit ce signal, et
+   * non `disabled()`, pour sortir de la tabulation et s'annoncer inactif dans un groupe gele.
+   * Le gel du groupe est un etat d'INTERFACE : il ne retire pas le champ de la validation (le
+   * schema le fait, par `disabled()`).
+   */
+  protected readonly desactive: import("@angular/core").Signal<boolean>;
+  /**
+   * L'aide a afficher : celle du champ, suivie des raisons de desactivation quand il l'est
+   * (« Reserve aux comptes Corporate »). Un champ grise sans raison laisse chercher pourquoi.
+   */
+  protected readonly aideEtRaisons: import("@angular/core").Signal<string | null>;
+  /** Appele par Signal Forms pour amener le focus sur un champ en erreur. */
+  focus(options?: FocusOptions): void;
+  protected texteSaisi(evenement: Event): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ContratDeChamp, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ContratDeChamp, never, never, {
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "dirty": {
+      "alias": "dirty";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledReasons": {
+      "alias": "disabledReasons";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "minLength": {
+      "alias": "minLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxLength": {
+      "alias": "maxLength";
+      "required": false;
+      "isSignal": true;
+    };
+    "pattern": {
+      "alias": "pattern";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/**
+ * Base des champs a bornes de valeur (nombre, montant, date) : `min` et `max` du schema, du type
+ * de la valeur (`NonNullable<TValeur>`, comme Signal Forms les pose).
+ */
+export declare abstract class ContratDeChampABornes<TValeur> extends ContratDeChamp {
+  readonly min: import("@angular/core").InputSignal<NonNullable<TValeur> | undefined>;
+  readonly max: import("@angular/core").InputSignal<NonNullable<TValeur> | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ContratDeChampABornes<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ContratDeChampABornes<any>, never, never, {
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
 /** Base des champs dont la valeur est le texte saisi. */
-declare abstract class ControleDeSaisie extends ContratDeChamp implements FormValueControl<string> {
-    readonly value: _angular_core.ModelSignal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ControleDeSaisie, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ControleDeSaisie, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+export declare abstract class ControleDeSaisie extends ContratDeChamp implements FormValueControl<string> {
+  readonly value: import("@angular/core").ModelSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ControleDeSaisie, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ControleDeSaisie, never, never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * Base des cases a cocher et des interrupteurs : le meme contrat, avec `checked` a la place de
+ * `value` (FormCheckboxControl).
+ *
+ * ⚠️ `readonly` n'existe pas sur une case native : le clic la bascule quand meme. `surClic`
+ * l'annule avant la bascule (`preventDefault`), `surBascule` n'ecrit le modele qu'hors lecture
+ * seule ; le gabarit pose `aria-readonly`. La case reste focalisable et lue (a l'inverse de
+ * `disabled`, qui la retire de la tabulation).
+ */
+export declare abstract class ContratDeCase extends ContratDeChamp implements FormCheckboxControl {
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  /**
+   * A brancher sur `(click)` de la case native : en lecture seule, le clic (souris, ou Espace qui
+   * passe par lui) est annule AVANT la bascule — aucun etat coche transitoire expose a l'arbre
+   * d'accessibilite, aucun evenement `input` ni `change`.
+   */
+  protected surClic(evenement: MouseEvent): void;
+  /** A brancher sur `(change)` de la case native : ecrit le modele (filet si le clic passe). */
+  protected surBascule(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ContratDeCase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ContratDeCase, never, never, {
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+  }, never, never, true, never>;
+}
+/**
+ * Un choix d'une liste : `st-select`, `st-combobox`, `st-multiselect`.
+ *
+ * La `valeur` part dans le modele, le `libelle` s'affiche : un identifiant
+ * technique ne s'affiche jamais, et un libelle traduit ne s'envoie jamais.
+ */
+export interface OptionDeListe {
+  readonly valeur: string;
+  readonly libelle: string;
+  /** Une precision sous le libelle (« Reglement brut en temps reel »), lue avec l'option. */
+  readonly aide?: string;
+  readonly desactivee?: boolean;
+  /** Regroupe les options consecutives sous un intitule (`optgroup`). */
+  readonly groupe?: string;
 }
-
 /**
  * `empilee` : etiquette au-dessus du controle, pour un champ texte.
- * `case` : controle AVANT son etiquette, pour une case a cocher ou un interrupteur.
+ * `case` : controle AVANT son etiquette, centre sur la colonne de textes, pour une case a cocher.
+ * `reglage` : controle APRES son etiquette (texte a gauche, commande a droite), pour un
+ * interrupteur dans sa ligne de reglage (planches 3a, 3b).
+ * `en-ligne` : etiquette A GAUCHE du controle, sur une colonne commune reglable
+ * par `--st-champ-largeur-libelle` (formulaire horizontal de back-office).
+ */
+export type DispositionDeChamp = 'empilee' | 'case' | 'reglage' | 'en-ligne';
+/**
+ * Les jetons d'`autocomplete` qu'un champ du socle emploie (WHATWG, « autofill field names ») :
+ * WCAG 1.3.5 demande le bon jeton sur tout champ qui porte une donnee de la personne. Un jeton
+ * absent de la liste reste possible (`section-*`, `shipping`…) par la chaine libre.
+ */
+export type TypeDAutocompletion = 'off' | 'on' | 'name' | 'honorific-prefix' | 'given-name' | 'additional-name' | 'family-name' | 'nickname' | 'email' | 'username' | 'new-password' | 'current-password' | 'one-time-code' | 'organization-title' | 'organization' | 'street-address' | 'address-line1' | 'address-line2' | 'address-line3' | 'address-level1' | 'address-level2' | 'country' | 'country-name' | 'postal-code' | 'cc-name' | 'cc-number' | 'cc-exp' | 'cc-csc' | 'transaction-currency' | 'transaction-amount' | 'language' | 'bday' | 'sex' | 'tel' | 'tel-national' | 'url' | (string & Record<never, never>);
+/** Le clavier virtuel adapte (`inputmode`) : `numeric` pour un code, `decimal` pour un montant. */
+export type ModeDeSaisie = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+/**
+ * Sans accents ni casse : « eleve » trouve « Eleve ».
+ *
+ * La casse se replie dans la langue de la page (`ST_LOCALE`), passee par le composant qui cherche :
+ * les regles de casse ne sont pas les memes d'une langue a l'autre. Sans locale, celle du moteur.
+ */
+export declare function normaliserPourRecherche(texte: string, locale?: string): string;
+/** Options dont le libelle CONTIENT le texte cherche, sans accents ni casse. */
+export declare function filtrerOptions(options: readonly OptionDeListe[], recherche: string, locale?: string): readonly OptionDeListe[];
+/** Un bloc d'options consecutives partageant le meme `groupe` (ou aucun). */
+export interface BlocDOptions {
+  /** Identite stable du bloc dans un `@for track` : la valeur de sa premiere option. */
+  readonly cle: string;
+  readonly groupe: string | null;
+  readonly options: readonly OptionDeListe[];
+}
+/**
+ * Regroupe des options CONSECUTIVES d'un meme `groupe`, dans l'ordre fourni (`st-select`,
+ * `st-combobox`, `st-multiselect`) : un `optgroup` natif ou un `role=group` ARIA se construit sur
+ * des blocs adjacents, jamais en triant par nom de groupe.
+ */
+export declare function groupesDOptions(options: readonly OptionDeListe[]): readonly BlocDOptions[];
+/** Identifiants que la base cite dans `aria-describedby`. */
+interface IdentifiantsDeDescription {
+  readonly aide: string;
+  readonly erreur: string;
+}
+/**
+ * Ce que le champ et le groupe partagent : l'aide, les erreurs, l'obligation, et le calcul des
+ * descriptions qui les relie.
+ *
+ * ⚠️ **Une base, et non deux copies** (lot 215). `st-form-field` et `st-fieldset` recopiaient le
+ * meme calcul ; la copie du groupe avait garde le defaut que le champ avait perdu (une aide vide
+ * citee dans `aria-describedby`, constat A1163). Le repere d'erreur est donc le meme partout :
+ * memes messages, meme ordre, meme invalidite.
+ *
+ * ⚠️ **Un champ montre une seule erreur par defaut** : la premiere, celle que le recapitulatif
+ * d'erreurs dit pour ce champ. Deux messages differents pour un meme champ, l'un sous les yeux et
+ * l'autre dans le recapitulatif, font chercher la seconde erreur qui n'existe pas.
+ * `toutesLesErreurs` les montre toutes, pour un champ dont chaque regle se corrige a part (mot de
+ * passe) ou dont chaque erreur vise une partie distincte (un fichier refuse chacun).
+ *
+ * ⚠️ **Un groupe les montre toutes par defaut** (`st-fieldset` redefinit l'entree a vrai) : ses
+ * erreurs visent des parties distinctes (debut ET fin d'une plage), et taire la seconde laisserait
+ * une partie `aria-invalid` sans aucun texte qui dise pourquoi (WCAG 3.3.1).
+ */
+declare abstract class PorteurDErreurs {
+  private readonly libelles;
+  private readonly locale;
+  /** Aide permanente : format attendu, exemple. Une chaine vide n'est pas une aide. */
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly erreurs: import("@angular/core").InputSignal<readonly ErreurAffichable[]>;
+  /**
+   * ⚠️ Faux tant que la personne n'a pas quitte le champ ou tente l'envoi (UX-3) : un formulaire
+   * vierge couvert d'erreurs accuse avant qu'on ait rien fait.
+   */
+  readonly afficherErreurs: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Montre toutes les erreurs au lieu de la premiere (vrai par defaut sur un groupe). */
+  readonly toutesLesErreurs: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly obligatoire: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Racine des identifiants, tiree du service d'application (jamais d'un compteur de module). */
+  protected readonly racine: string;
+  /** Les identifiants de l'aide et de l'erreur, construits par la classe fille depuis `racine`. */
+  abstract readonly identifiants: IdentifiantsDeDescription;
+  protected readonly libelleObligatoire: import("@angular/core").Signal<string>;
+  /** L'aide a rendre : `null` pour une aide absente OU vide, le gabarit et `aria-describedby` d'accord. */
+  protected readonly aideRendue: import("@angular/core").Signal<string | null>;
+  /** Messages a afficher, dans la langue courante. Vide tant qu'ils ne doivent pas l'etre. */
+  protected readonly messages: import("@angular/core").Signal<string[]>;
+  /** Vrai quand des messages sont AFFICHES : c'est lui que lisent `aria-invalid` et le lisere. */
+  readonly enErreur: import("@angular/core").Signal<boolean>;
+  /**
+   * ⚠️ Seuls les elements PRESENTS sont references : un `aria-describedby` qui vise un identifiant
+   * absent est ignore par certains lecteurs d'ecran — tout entier, y compris les references valides
+   * qui l'accompagnent. Ordre de lecture : aide, descriptions propres (complement), erreur.
+   */
+  readonly descriptions: import("@angular/core").Signal<string | null>;
+  /** `st-champ` ou `st-groupe` : lu une fois, a la construction. */
+  protected abstract prefixeDIdentifiant(): string;
+  /** Identifiants propres a la classe fille, lus entre l'aide et l'erreur. */
+  protected descriptionsPropres(): readonly string[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<PorteurDErreurs, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<PorteurDErreurs, never, never, {
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "erreurs": {
+      "alias": "erreurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "afficherErreurs": {
+      "alias": "afficherErreurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "toutesLesErreurs": {
+      "alias": "toutesLesErreurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "obligatoire": {
+      "alias": "obligatoire";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Un texte a rendre, ou `null` : une chaine vide ou blanche ne se rend pas. */
+declare function texteRendu(texte: string | null | undefined): string | null;
+/**
+ * `libelle` : l'etiquette de champ, 14/500 (D18).
+ * `micro-capitales` : 11/600 en capitales espacees, pour un champ de dialogue ou de panneau dense
+ * (planches 4, 5, 13) ; le controle, lui, ne change pas.
  */
-type DispositionDeChamp = 'empilee' | 'case';
+export type PresentationDeLibelle = 'libelle' | 'micro-capitales';
 /**
  * Etiquette, aide, erreur et controle d'un champ de saisie — et le cablage qui
  * les relie.
@@ -169,73 +584,123 @@ type DispositionDeChamp = 'empilee' | 'case';
  * `aria-invalid` : c'est precisement le code que l'on croit fini et qui se perd,
  * un champ specialise a la fois.
  *
- * L'ordre visuel suit celui de la lecture : etiquette, aide, erreur, controle.
- * L'erreur est AU-DESSUS du controle, pour etre vue avant de retaper.
+ * Anatomie (planche 3b, reference unique D23) : une ligne d'en-tete (etiquette 14/500, mention
+ * « (obligatoire) » ou meta `[stMeta]` a droite), l'aide, puis le message — l'erreur, ou a
+ * defaut l'indication projetee `[stIndication]` (« Conforme au registre », « Selectionnable &
+ * copiable ») —, puis le controle. L'erreur est AU-DESSUS du controle, pour etre vue avant de
+ * retaper.
+ *
+ * ⚠️ **Le lisere d'erreur vit dans la gouttiere**, a -12 px du controle et sur SA hauteur : il
+ * ne decale rien, et le controle garde sa largeur et son bord. Le MESSAGE, lui, est au-dessus du
+ * controle (D23) : il le pousse vers le bas de sa hauteur (30 px pour une ligne). Chromium compte
+ * ce decalage au CLS, meme juste apres Tab : il est mesure au banc, et non nie.
  *
  * ⚠️ **L'erreur n'est pas une region vivante.** Annoncee a la perte du focus, elle
  * couperait la lecture du champ suivant, ou la personne est deja passee. Elle est
  * reliee au controle, donc lue quand on y revient ; a l'envoi, c'est le
  * recapitulatif d'erreurs qui prend le focus et les enumere.
  */
-declare class StFormField {
-    private readonly libelles;
-    private readonly locale;
-    private readonly element;
-    /**
-     * ⚠️ OBLIGATOIRE et toujours visible (UX-1). Un texte indicatif ne le remplace
-     * jamais : il disparait a la premiere frappe.
-     */
-    readonly libelle: _angular_core.InputSignal<string>;
-    /** Aide permanente : format attendu, exemple. Lue apres l'etiquette. */
-    readonly aide: _angular_core.InputSignal<string | null>;
-    /** Texte complementaire tenu a jour par le controle, comme un compteur. */
-    readonly complement: _angular_core.InputSignal<string | null>;
-    readonly erreurs: _angular_core.InputSignal<readonly ErreurAffichable[]>;
-    /**
-     * ⚠️ Faux tant que la personne n'a pas quitte le champ ou tente l'envoi (UX-3) :
-     * un formulaire vierge couvert d'erreurs accuse avant qu'on ait rien fait.
-     */
-    readonly afficherErreurs: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly obligatoire: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /**
-     * ⚠️ Change l'ordre VISUEL, jamais celui du document : l'etiquette reste
-     * reliee par `for`, et l'ordre de tabulation ne passe que par le controle.
-     */
-    readonly disposition: _angular_core.InputSignal<DispositionDeChamp>;
-    /**
-     * Etiquette lue mais non affichee.
-     *
-     * ⚠️ Reservee a la RECHERCHE, ou l'icone, le bouton et la position en tete de
-     * page disent deja le but du champ. Partout ailleurs, une etiquette masquee est
-     * l'etiquette qui manque au moment ou l'on tape (UX-1).
-     */
-    readonly libelleMasque: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Identifiants du champ, lus par `stControleDeChamp` et par le gabarit. */
-    readonly identifiants: {
-        readonly controle: string;
-        readonly libelle: `${string}-libelle`;
-        readonly aide: `${string}-aide`;
-        readonly complement: `${string}-complement`;
-        readonly erreur: `${string}-erreur`;
-    };
-    protected readonly libelleObligatoire: _angular_core.Signal<string>;
-    /** Messages a afficher, dans la langue courante. Vide tant qu'ils ne doivent pas l'etre. */
-    protected readonly messages: _angular_core.Signal<string[]>;
-    /**
-     * Un clic sur l'etiquette d'un controle non natif n'y mene pas de lui-meme :
-     * on y amene le focus, comme le navigateur le fait pour un champ natif.
-     */
-    protected focaliserLeControle(): void;
-    /** Lu par le controle pour `aria-invalid`. */
-    readonly enErreur: _angular_core.Signal<boolean>;
-    /**
-     * ⚠️ Seuls les elements PRESENTS sont references : un `aria-describedby` qui
-     * vise un identifiant absent est ignore par certains lecteurs d'ecran — tout
-     * entier, y compris les references valides qui l'accompagnent.
-     */
-    readonly descriptions: _angular_core.Signal<string | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StFormField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StFormField, "st-form-field", never, { "libelle": { "alias": "libelle"; "required": true; "isSignal": true; }; "aide": { "alias": "aide"; "required": false; "isSignal": true; }; "complement": { "alias": "complement"; "required": false; "isSignal": true; }; "erreurs": { "alias": "erreurs"; "required": false; "isSignal": true; }; "afficherErreurs": { "alias": "afficherErreurs"; "required": false; "isSignal": true; }; "obligatoire": { "alias": "obligatoire"; "required": false; "isSignal": true; }; "disposition": { "alias": "disposition"; "required": false; "isSignal": true; }; "libelleMasque": { "alias": "libelleMasque"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+export declare class StFormField extends PorteurDErreurs {
+  /**
+   * ⚠️ OBLIGATOIRE et toujours visible (UX-1). Un texte indicatif ne le remplace
+   * jamais : il disparait a la premiere frappe.
+   */
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  /** Texte complementaire tenu a jour par le controle, comme un compteur. Lu apres l'aide. */
+  readonly complement: import("@angular/core").InputSignal<string | null>;
+  /**
+   * ⚠️ Change l'ordre VISUEL, jamais celui du document : l'etiquette reste
+   * reliee par `for`, et l'ordre de tabulation ne passe que par le controle.
+   * `en-ligne` revient a `empilee` sous la rupture `md` de sa propre largeur.
+   */
+  readonly disposition: import("@angular/core").InputSignal<DispositionDeChamp>;
+  /** Le style de l'etiquette ; n'agit qu'en disposition `empilee` ou `en-ligne`. */
+  readonly presentation: import("@angular/core").InputSignal<PresentationDeLibelle>;
+  /**
+   * Etiquette lue mais non affichee.
+   *
+   * ⚠️ Reservee a la RECHERCHE, ou l'icone, le bouton et la position en tete de
+   * page disent deja le but du champ. Partout ailleurs, une etiquette masquee est
+   * l'etiquette qui manque au moment ou l'on tape (UX-1).
+   */
+  readonly libelleMasque: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Identifiants d'elements DU CONTROLE qui le decrivent (le suffixe « Contrats » d'un
+   * `st-input`), lus apres la meta : une unite dite dans le cadre n'est pas perdue au focus.
+   */
+  readonly descriptionsDuControle: import("@angular/core").InputSignal<readonly string[]>;
+  /** Identifiants du champ, lus par `stControleDeChamp` et par le gabarit. */
+  readonly identifiants: {
+    readonly controle: string;
+    readonly libelle: `${string}-libelle`;
+    readonly aide: `${string}-aide`;
+    readonly meta: `${string}-meta`;
+    readonly indication: `${string}-indication`;
+    readonly complement: `${string}-complement`;
+    readonly erreur: `${string}-erreur`;
+  };
+  protected readonly complementRendu: import("@angular/core").Signal<string | null>;
+  /**
+   * Le controle projete, par reference : c'est lui que le clic sur l'etiquette focalise (et non
+   * un `querySelector` sur un identifiant, qui trouverait le controle d'un champ imbrique).
+   */
+  private readonly controle;
+  /**
+   * La meta et l'indication projetees existent-elles ? Relevees au rendu, et non par une requete
+   * de contenu : relayees par un champ du socle (`st-input` projette `[stMeta]` et
+   * `[stIndication]` plus loin), elles echappent aux requetes de `st-form-field`.
+   */
+  private readonly zoneDeMeta;
+  private readonly zoneDIndication;
+  private readonly metaPresente;
+  private readonly indicationPresente;
+  /**
+   * Un libelle riche `[stLibelle]` est-il projete (lot 218) ? Il remplace alors le texte de
+   * `libelle`, qui reste le nom cite par le recapitulatif d'erreurs et doit dire la meme chose.
+   */
+  private readonly zoneDuLibelleRiche;
+  protected readonly libelleRichePresent: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  protected prefixeDIdentifiant(): string;
+  protected descriptionsPropres(): readonly string[];
+  /**
+   * Un clic sur l'etiquette d'un controle non natif n'y mene pas de lui-meme :
+   * on y amene le focus, comme le navigateur le fait pour un champ natif.
+   */
+  protected focaliserLeControle(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StFormField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StFormField, "st-form-field", never, {
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "complement": {
+      "alias": "complement";
+      "required": false;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "presentation": {
+      "alias": "presentation";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleMasque": {
+      "alias": "libelleMasque";
+      "required": false;
+      "isSignal": true;
+    };
+    "descriptionsDuControle": {
+      "alias": "descriptionsDuControle";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["controle"], ["[stLibelle]", "[stAide]", "[stMeta]", "[stIndication]", "*"], true, never>;
 }
 /**
  * Pose sur l'element natif d'un champ le cablage de son `st-form-field` :
@@ -245,21 +710,74 @@ declare class StFormField {
  * validation du navigateur a l'envoi : une bulle « Veuillez renseigner ce champ »
  * dans la langue du NAVIGATEUR, pas dans celle de l'application, et qui double
  * le message du socle.
+ *
+ * `aria-errormessage` s'AJOUTE a `aria-describedby` (qui garde l'erreur) : les lecteurs
+ * d'ecran qui le lisent annoncent l'erreur comme telle, les autres la lisent en description.
  */
-declare class StControleDeChamp {
-    protected readonly champ: StFormField;
-    /**
-     * ⚠️ `label for` n'etiquette que les elements natifs de formulaire. Le
-     * declencheur d'une selection multiple est un `div` de role `combobox` : sans
-     * `aria-labelledby`, il n'aurait aucun nom, et l'etiquette visible ne dirait
-     * rien au lecteur d'ecran.
-     */
-    protected readonly etiquetable: boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StControleDeChamp, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StControleDeChamp, "[stControleDeChamp]", never, {}, {}, never, never, true, never>;
+export declare class StControleDeChamp {
+  protected readonly champ: StFormField;
+  /**
+   * ⚠️ `label for` n'etiquette que les elements natifs de formulaire. Le
+   * declencheur d'une selection multiple est un `div` de role `combobox` : sans
+   * `aria-labelledby`, il n'aurait aucun nom, et l'etiquette visible ne dirait
+   * rien au lecteur d'ecran.
+   */
+  protected readonly etiquetable: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StControleDeChamp, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StControleDeChamp, "[stControleDeChamp]", never, {}, {}, never, never, true, never>;
 }
-
-type TypeDeSaisie = 'text' | 'email' | 'tel' | 'url' | 'search';
+/**
+ * Base des champs de texte dont la LONGUEUR se compte (`st-input`, `st-textarea`, lot 217) : un
+ * comportement, ecrit une fois.
+ *
+ * - `maxLength` (du schema ou pose a la main) : compteur en complement, « N caracteres
+ *   restants », puis « N caracteres en trop » au depassement.
+ * - `minLength` : « Saisissez au moins N caracteres. » en aide, si l'appelant n'en donne pas.
+ *
+ * ⚠️ **Le compteur n'est pas annonce a chaque frappe** : une region vivante qui change a chaque
+ * caractere recouvre ce que la personne tape. Il est RELIE au champ — donc lu quand on y
+ * revient — et seuls les seuils (20, 10, 0 restants) et le depassement s'annoncent (UX-11), par
+ * `annonce`, que le gabarit rend dans sa region `polite`.
+ *
+ * ⚠️ **Pas de `maxlength` natif** : un texte colle serait tronque en silence. Pendant la frappe,
+ * le compteur SEUL dit le depassement (rouge, « N en trop », annonce polie) : rien ne s'insere
+ * au-dessus du champ sous le curseur (P6). Hors formulaire, le depassement devient une erreur
+ * LOCALE (`maxLength`), affichee et posee en `aria-invalid` a la SORTIE du champ ; dans un
+ * formulaire, l'erreur du schema suit `touched`, comme avant.
+ *
+ * Le gabarit relie `compteur()` au `complement` de `st-form-field`, `aideAffichee()`, `erreurs()`
+ * et `afficherErreurs()` a l'enveloppe, et branche `surSortie()` sur la perte du focus ; l'hote
+ * pose `data-depassement` quand `enDepassement()`.
+ */
+declare abstract class ControleDeSaisieCompte extends ControleDeSaisie {
+  protected readonly libelles: Signal<import("@starterlib/ui").LibellesUi>;
+  protected readonly annonce: AnnonceLocale;
+  private readonly restants;
+  protected readonly enDepassement: Signal<boolean>;
+  protected readonly compteur: Signal<string | null>;
+  /**
+   * L'aide fournie (et les raisons de desactivation), sinon « Saisissez au moins N caracteres. »
+   * quand le schema le demande ; puis « Verification… » pendant une validation asynchrone.
+   */
+  protected readonly aideAffichee: Signal<string | null>;
+  /** Les erreurs du formulaire, et le depassement local s'il n'y est pas deja. */
+  protected readonly erreurs: Signal<readonly ErreurAffichable[]>;
+  /** La personne est-elle deja sortie du champ ? Pose au `blur`, pour l'erreur LOCALE seulement. */
+  private readonly sorti;
+  /**
+   * Les erreurs se montrent a la sortie du champ, jamais pendant la frappe : `touched` dans un
+   * formulaire ; hors formulaire (personne ne pose `touched`), la sortie du champ, pour que le
+   * depassement local devienne une erreur affichee.
+   */
+  protected readonly afficherErreurs: Signal<boolean>;
+  constructor();
+  protected surSortie(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ControleDeSaisieCompte, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ControleDeSaisieCompte, never, never, {}, {}, never, never, true, never>;
+}
+export type TypeDeSaisie = 'text' | 'email' | 'tel' | 'url' | 'search';
+/** Presentation des chiffres de la valeur saisie. */
+export type ChiffresDeSaisie = 'texte' | 'reference';
 /**
  * Champ de saisie d'une ligne, integre a Signal Forms.
  *
@@ -267,6 +785,10 @@ type TypeDeSaisie = 'text' | 'email' | 'tel' | 'url' | 'search';
  * <st-input libelle="Nom du beneficiaire" autocomplete="name" [formField]="virement.beneficiaire" />
  * <!-- ou, sans formulaire : -->
  * <st-input libelle="Reference" [(value)]="reference" />
+ * <!-- prefixe et suffixe DANS le cadre du champ : -->
+ * <st-input libelle="Quantite" [(value)]="quantite">
+ *   <span stSuffixe>Contrats</span>
+ * </st-input>
  * ```
  *
  * ⚠️ **Contrat Signal Forms, noms anglais.** `value`, `errors`, `touched`,
@@ -277,49 +799,184 @@ type TypeDeSaisie = 'text' | 'email' | 'tel' | 'url' | 'search';
  *
  * ⚠️ **Pas d'attribut `maxlength` natif.** Il TRONQUE en silence un texte colle
  * trop long : la personne croit avoir saisi sa reference entiere, et n'en envoie
- * que le debut. La limite passe par la validation, qui DIT le depassement.
- */
-declare class StInput extends ControleDeSaisie {
-    readonly type: _angular_core.InputSignal<TypeDeSaisie>;
-    /**
-     * WCAG 1.3.5 : identifie le but du champ, pour le remplissage automatique et les
-     * aides techniques. `null` : laisse le navigateur decider.
-     */
-    readonly autocomplete: _angular_core.InputSignal<string | null>;
-    /** Clavier virtuel adapte : `numeric`, `decimal`, `email`… */
-    readonly inputmode: _angular_core.InputSignal<string | null>;
-    protected surSaisie(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StInput, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StInput, "st-input", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "inputmode": { "alias": "inputmode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+ * que le debut. La limite passe par la validation, qui DIT le depassement : `maxLength`
+ * (du schema ou pose a la main) donne un compteur en complement, `minLength` une aide
+ * automatique, comme `st-textarea` (`ControleDeSaisieCompte`, lot 217).
+ *
+ * ⚠️ **Prefixe et suffixe PROJETES, jamais recomposes a cote** (`[stPrefixe]`,
+ * `[stSuffixe]`, ou `icone` pour un glyphe de tete). Le cadre porte alors le filet, le fond,
+ * l'anneau et l'erreur : un seul cadre (EA-11), la meme hauteur. Un emplacement n'entre PAS
+ * dans le NOM du champ, mais un emplacement de texte entre dans sa DESCRIPTION (lue au focus,
+ * apres l'aide et la meta) : l'unite « Contrats (= 303 625.00 CHF) » n'est jamais perdue.
+ * Un clic dans le cadre, hors d'un element interactif, donne le focus a la zone de frappe.
+ * Trop long pour la largeur, un emplacement de texte se coupe (points de suspension) : la zone
+ * de frappe garde toujours au moins huit chiffres visibles (WCAG 1.4.10). Un emplacement
+ * interactif se projette directement (`<button stSuffixe stIconButton …>`), jamais dans un
+ * `span` : il serait coupe avec lui.
+ */
+export declare class StInput extends ControleDeSaisieCompte {
+  private readonly racineDuCadre;
+  /** Identifiants des emplacements, references en description quand ils portent du texte. */
+  protected readonly idPrefixe: string;
+  protected readonly idSuffixe: string;
+  private readonly zoneDePrefixe;
+  private readonly zoneDeSuffixe;
+  /** Emplacements qui decrivent le champ, releves au rendu (le contenu projete peut changer). */
+  protected readonly emplacementsQuiDecrivent: import("@angular/core").WritableSignal<readonly string[]>;
+  readonly type: import("@angular/core").InputSignal<TypeDeSaisie>;
+  /**
+   * WCAG 1.3.5 : identifie le but du champ, pour le remplissage automatique et les
+   * aides techniques. `null` : laisse le navigateur decider.
+   */
+  readonly autocomplete: import("@angular/core").InputSignal<TypeDAutocompletion | null>;
+  /** Clavier virtuel adapte : `numeric`, `decimal`, `email`… */
+  readonly inputmode: import("@angular/core").InputSignal<ModeDeSaisie | null>;
+  /** Glyphe decoratif de tete, dans le cadre (l'etiquette porte le sens). */
+  readonly icone: import("@angular/core").InputSignal<"iban" | "code" | "devise" | "fichier" | "message" | "menu" | "accessibilite" | "appareils" | "arborescence" | "asterisque" | "badge-coche" | "banque" | "batiment" | "bifurcation" | "billets" | "billets-envoi" | "billets-pile" | "boite" | "boite-de-reception" | "bouclier" | "bouclier-alerte" | "bouclier-coche" | "bouclier-coeur" | "bouclier-croix" | "bouclier-moitie" | "bouclier-recherche" | "bouclier-utilisateur" | "boussole" | "bouton-curseur" | "bulle-question" | "cadenas" | "cadenas-horloge" | "cadenas-ouvert" | "cadre-pied" | "cadre-texte" | "calendrier" | "calendrier-evenement" | "calendrier-horloge" | "calendrier-jour" | "calques" | "carte-bancaire" | "carte-bancaire-barre" | "carte-bancaire-cadenas" | "carte-contact" | "carte-identite" | "cartes-empilees" | "case-cochee" | "casse" | "cercle" | "cercle-alerte" | "cercle-chevron-bas" | "cercle-coche" | "cercle-coche-ouvert" | "cercle-croix" | "cercle-info" | "cercle-moins" | "cercle-plus" | "cercle-question" | "certificat" | "chandelier" | "chargement" | "cheque" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "chevrons-droite" | "chevrons-haut-bas" | "cle" | "cloche" | "cloche-sonnerie" | "coche" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier-image" | "fichier-pdf" | "fichier-texte" | "filtre" | "filtre-barre" | "filtre-lignes" | "fleche-bas" | "fleche-bas-gauche" | "fleche-bas-ligne" | "fleche-droite" | "fleche-gauche" | "fleche-haut" | "fleche-haut-droite" | "fleche-haut-ligne" | "fleche-large-haut" | "fleches-gauche-droite" | "flocon" | "flou" | "formes" | "globe" | "graphique-anneau" | "graphique-barres" | "graphique-barres-cadre" | "graphique-camembert" | "graphique-ligne" | "graphique-lignes" | "grille" | "grille-lignes" | "hexagone" | "historique" | "horloge" | "horloge-fleche" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu-ouvert" | "minuteur" | "mise-au-point" | "mise-en-page-image" | "moins" | "nuage-barre" | "nuage-televerser" | "octogone-alerte" | "oeil" | "oeil-barre" | "panneau-gauche" | "parametres" | "parapluie" | "parchemin" | "pieces" | "plus" | "pointeur" | "points" | "points-verticaux" | "portefeuille" | "portefeuille-cartes" | "presse-papiers-coche" | "presse-papiers-horloge" | "priorite-haute" | "rafraichir" | "recherche" | "recherche-barre" | "recherche-texte" | "rectangle-points" | "recu" | "redemarrer" | "reglages" | "regle" | "reseau-jauge" | "rotation-arriere" | "routeur" | "sablier" | "sablier-bas" | "sablier-haut" | "sac-argent" | "sans-contact" | "serveur" | "soleil" | "style-de-trait" | "synchro" | "synchro-probleme" | "tableau" | "tableau-de-bord" | "tableau-de-bord-plus" | "tablette" | "tabulation" | "telecharger" | "telephone-mobile" | "televerser" | "tendance-baisse" | "tendance-hausse" | "terminal" | "tirelire" | "triangle-alerte" | "triangle-bas" | "triangle-haut" | "trombone" | "utilisateur" | "utilisateur-crayon" | "utilisateurs" | "wifi" | "wifi-barre" | null>;
+  /**
+   * `reference` : IBAN, BIC, reference structuree — chasse fixe, chiffres a zero barre
+   * (`--st-chiffres-references`), pour qu'un 0 ne se lise pas O ; de gauche a droite en RTL.
+   */
+  readonly chiffres: import("@angular/core").InputSignal<ChiffresDeSaisie>;
+  /** Le style de l'etiquette (voir `st-form-field`). */
+  readonly presentation: import("@angular/core").InputSignal<PresentationDeLibelle>;
+  /**
+   * Identifiants d'autres textes qui decrivent le champ (`aria-describedby`), lus entre l'aide et
+   * l'erreur : les essais restants de `st-challenge` (audit UI du 2026-09-27, D-20). Des elements
+   * PRESENTS seulement : un identifiant absent fait ignorer toute la description par certains
+   * lecteurs d'ecran.
+   */
+  readonly decritPar: import("@angular/core").InputSignal<readonly string[]>;
+  /** Ce qui decrit le controle : les textes de l'appelant, puis les emplacements de texte. */
+  protected readonly descriptionsDuControle: import("@angular/core").Signal<readonly string[]>;
+  /**
+   * Des valeurs a PROPOSER, jamais a imposer : une liste `datalist` native, que le navigateur offre
+   * sous le champ et filtre a la frappe ; toute autre saisie reste admise (la ville d'une adresse,
+   * D133). `null` ou vide : aucune. Une liste FERMEE est un `st-select` ; une longue liste a filtrer
+   * dans une liste du socle, un `st-combobox`.
+   */
+  readonly suggestions: import("@angular/core").InputSignal<readonly string[] | null>;
+  protected readonly idDesSuggestions: string;
+  protected readonly avecSuggestions: import("@angular/core").Signal<boolean>;
+  /**
+   * L'indicateur d'attente n'apparait qu'apres `rythme.delai.attente` et reste au moins
+   * `rythme.tenue.affichageMinimal` : une verification de 150 ms ne fait rien clignoter.
+   */
+  protected readonly attenteVisible: import("@angular/core").Signal<boolean>;
+  /**
+   * Un courriel, un telephone, une adresse web, une reference structuree (IBAN, BIC) restent de
+   * gauche a droite en RTL : latins par nature, ils s'y alignaient a droite et un IBAN trop long
+   * pour la largeur y perdait son debut (« H93 0076… » au lieu de « CH93 0076… », instantanes du
+   * lot 217).
+   */
+  protected readonly sens: import("@angular/core").Signal<"ltr" | null>;
+  constructor();
+  /**
+   * Le cadre est UN champ : un clic sur le prefixe, l'icone, le suffixe texte ou la marge donne
+   * le focus a la zone de frappe (le survol du cadre l'a promis). Un bouton projete garde le sien.
+   */
+  protected surPressionDuCadre(evenement: MouseEvent): void;
+  protected surSaisie(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StInput, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StInput, "st-input", never, {
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "inputmode": {
+      "alias": "inputmode";
+      "required": false;
+      "isSignal": true;
+    };
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "chiffres": {
+      "alias": "chiffres";
+      "required": false;
+      "isSignal": true;
+    };
+    "presentation": {
+      "alias": "presentation";
+      "required": false;
+      "isSignal": true;
+    };
+    "decritPar": {
+      "alias": "decritPar";
+      "required": false;
+      "isSignal": true;
+    };
+    "suggestions": {
+      "alias": "suggestions";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stMeta]", "[stAide]", "[stIndication]", "[stPrefixe]", "[stSuffixe]"], true, never>;
 }
-
 /**
  * Zone de texte, integree a Signal Forms, avec compteur quand une longueur
- * maximale est fixee.
- *
- * ⚠️ **Le compteur n'est pas annonce a chaque frappe** : une region vivante qui
- * change a chaque caractere recouvre ce que la personne tape. Il est RELIE a la
- * zone — donc lu quand on y revient — et seuls les seuils (20, 10, 0 restants)
- * et le depassement s'annoncent (UX-11).
- *
- * ⚠️ **Pas de `maxlength` natif**, meme raison que `st-input` : un texte colle
- * serait tronque en silence. Le compteur affiche le depassement, la validation
- * le refuse.
- */
-declare class StTextarea extends ControleDeSaisie {
-    private readonly libelles;
-    readonly lignes: _angular_core.InputSignal<number>;
-    /** Contrat Signal Forms : la longueur maximale fixee par le schema. */
-    readonly maxLength: _angular_core.InputSignal<number | undefined>;
-    protected readonly annonce: AnnonceLocale;
-    private readonly restants;
-    protected readonly compteur: _angular_core.Signal<string | null>;
-    constructor();
-    protected surSaisie(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StTextarea, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StTextarea, "st-textarea", never, { "lignes": { "alias": "lignes"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+ * maximale est fixee : le compteur, ses annonces aux seuils, le depassement local et l'aide de
+ * longueur minimale sont ceux de `ControleDeSaisieCompte`, partages avec `st-input`.
+ *
+ * La zone suit son texte (`field-sizing: content`), bornee entre `lignes` et `lignesMax` :
+ * jamais une fente d'une ligne, jamais une page entiere ; la poignee respecte les memes bornes.
+ */
+export declare class StTextarea extends ControleDeSaisieCompte {
+  /** Hauteur de depart, et hauteur minimale, en lignes. */
+  readonly lignes: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Hauteur maximale en lignes : au-dela, la zone defile. */
+  readonly lignesMax: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Bornes effectives : `lignesMax` ne descend jamais sous `lignes`. */
+  protected readonly bornes: import("@angular/core").Signal<{
+    lignes: number;
+    lignesMax: number;
+  }>;
+  protected surSaisie(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StTextarea, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StTextarea, "st-textarea", never, {
+    "lignes": {
+      "alias": "lignes";
+      "required": false;
+      "isSignal": true;
+    };
+    "lignesMax": {
+      "alias": "lignesMax";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
+/**
+ * Ce qu'un groupe (`st-fieldset`) dit a ses controles.
+ *
+ * ⚠️ `fieldset[disabled]` natif ne desactive que les elements de formulaire NATIFS. Un controle
+ * non natif (le declencheur `div role=combobox` d'une selection multiple) resterait focalisable,
+ * annonce actif et ouvrable dans un groupe gele : il lit donc ce jeton, par `ContratDeChamp`.
+ */
+interface GroupeDeSaisie {
+  /** Vrai quand le groupe entier est desactive. */
+  readonly disabled: Signal<boolean>;
+}
+declare const ST_GROUPE_DE_SAISIE: InjectionToken<GroupeDeSaisie>;
+/**
+ * `champs` : des champs empiles a 20 px (nom et IBAN d'un beneficiaire).
+ * `choix` : des cases ou des radios a 12 px (un groupe d'options, `st-radio-group`).
+ */
+export type ContenuDeGroupe = 'champs' | 'choix';
+/**
+ * `colonne` : les controles l'un sous l'autre.
+ * `en-ligne` : cote a cote, pour deux champs courts (une plage de dates) ; en colonne sous la
+ * rupture `sm` de la largeur du groupe.
+ */
+export type DispositionDeGroupe = 'colonne' | 'en-ligne';
 /**
  * Groupe de controles, nomme par sa QUESTION.
  *
@@ -327,34 +984,105 @@ declare class StTextarea extends ControleDeSaisie {
  * annonce « Oui, bouton radio » et « Non, bouton radio » : la reponse, jamais la
  * question. La legende est lue a l'entree dans le groupe.
  *
- * C'est le pendant de `st-form-field` pour un GROUPE : l'aide et l'erreur sont
- * reliees au `fieldset` par `aria-describedby`, et l'erreur porte sur le groupe
- * entier — « Choisissez un mode de reglement » — et non sur chaque option.
+ * C'est le pendant de `st-form-field` pour un GROUPE, sur la meme base (`PorteurDErreurs`) :
+ * l'aide et l'erreur sont reliees au `fieldset` par `aria-describedby`, l'erreur porte sur le
+ * groupe entier — « Choisissez un mode de reglement » — et non sur chaque option, et son lisere
+ * est a la place de celui du champ : dans la gouttiere, sur la hauteur des controles.
  *
  * ⚠️ L'obligation se dit dans la legende, en texte : `aria-required` n'est pas
  * valide sur un groupe, et `required` natif ferait parler le navigateur dans sa
- * propre langue.
- */
-declare class StFieldset {
-    private readonly libelles;
-    private readonly locale;
-    /** La question posee par le groupe. Obligatoire. */
-    readonly legende: _angular_core.InputSignal<string>;
-    readonly aide: _angular_core.InputSignal<string | null>;
-    readonly erreurs: _angular_core.InputSignal<readonly ErreurAffichable[]>;
-    readonly afficherErreurs: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly obligatoire: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    private readonly base;
-    protected readonly identifiantAide: string;
-    protected readonly identifiantErreur: string;
-    protected readonly libelleObligatoire: _angular_core.Signal<string>;
-    protected readonly messages: _angular_core.Signal<string[]>;
-    protected readonly enErreur: _angular_core.Signal<boolean>;
-    protected readonly descriptions: _angular_core.Signal<string | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StFieldset, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StFieldset, "st-fieldset", never, { "legende": { "alias": "legende"; "required": true; "isSignal": true; }; "aide": { "alias": "aide"; "required": false; "isSignal": true; }; "erreurs": { "alias": "erreurs"; "required": false; "isSignal": true; }; "afficherErreurs": { "alias": "afficherErreurs"; "required": false; "isSignal": true; }; "obligatoire": { "alias": "obligatoire"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+ * propre langue. Un groupe a choix EXCLUSIF (`choixExclusif`, pose par `st-radio-group`) est un
+ * `radiogroup` : lui porte aussi `aria-required`, `aria-invalid` et `aria-readonly`.
+ *
+ * ⚠️ `disabled` pose le `fieldset[disabled]` NATIF, qui desactive d'un coup les controles natifs
+ * du groupe, et le fournit aux controles du socle (`ST_GROUPE_DE_SAISIE`) : un controle non natif
+ * (declencheur `div role=combobox`) doit lire `desactive()` de `ContratDeChamp` pour s'y plier
+ * (adoption par st-combobox et st-multiselect : lot 227). C'est un gel d'INTERFACE : la validation
+ * continue, le schema seul retire un champ (`disabled()`). La raison se dit en aide.
+ *
+ * ⚠️ Toutes les erreurs du groupe sont montrees par defaut (`toutesLesErreurs` vrai) : elles visent
+ * des parties distinctes, et chacune doit dire pourquoi sa partie est invalide.
+ */
+export declare class StFieldset extends PorteurDErreurs implements GroupeDeSaisie {
+  /** La question posee par le groupe. Obligatoire. */
+  readonly legende: import("@angular/core").InputSignal<string>;
+  /** L'ecart entre les controles : 20 px entre des champs, 12 entre des cases ou des radios. */
+  readonly contenu: import("@angular/core").InputSignal<ContenuDeGroupe>;
+  readonly disposition: import("@angular/core").InputSignal<DispositionDeGroupe>;
+  /** Toutes les erreurs du groupe, par defaut : chacune vise une partie distincte. */
+  readonly toutesLesErreurs: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Des radios : le `fieldset` devient un `radiogroup`, qui porte l'obligation, l'erreur et la
+   * lecture seule du groupe (ARIA ne les prevoit ni sur `group` ni sur `radio`).
+   */
+  readonly choixExclusif: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Lecture seule du groupe, annoncee par `aria-readonly` (groupe a `choixExclusif` seulement). */
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Desactive tous les controles du groupe (`fieldset[disabled]` natif, et jeton de groupe). */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Masque le groupe entier. */
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Identifiants d'autres textes qui decrivent le groupe (`aria-describedby`), lus entre l'aide et
+   * l'erreur : le recapitulatif de `st-recurrence-field` (lot 255), relie sans etre annonce.
+   */
+  readonly decritPar: import("@angular/core").InputSignal<readonly string[]>;
+  /** Identifiants de l'aide et de l'erreur, cites par `aria-describedby`. */
+  readonly identifiants: {
+    readonly aide: `${string}-aide`;
+    readonly erreur: `${string}-erreur`;
+  };
+  protected prefixeDIdentifiant(): string;
+  protected descriptionsPropres(): readonly string[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<StFieldset, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StFieldset, "st-fieldset", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "contenu": {
+      "alias": "contenu";
+      "required": false;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "toutesLesErreurs": {
+      "alias": "toutesLesErreurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "choixExclusif": {
+      "alias": "choixExclusif";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "decritPar": {
+      "alias": "decritPar";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-
 /**
  * Case a cocher, integree a Signal Forms.
  *
@@ -362,39 +1090,71 @@ declare class StFieldset {
  * <st-checkbox libelle="J'accepte les conditions generales" [formField]="inscription.conditions" />
  * ```
  *
- * Un element `input type="checkbox"` natif : Espace coche, l'etat est annonce,
- * et la case suit le reglage de contraste du systeme sans rien ecrire.
+ * Un element `input type="checkbox"` natif, dessine par le socle (planches 3a, 3b) : Espace coche,
+ * l'etat est annonce, et la case est la meme sous Windows, macOS et Android. La ligne entiere (case,
+ * etiquette, aide) fait 44 px au moins ; cochee, elle se teinte ; en erreur, elle rougit, la case
+ * double son filet et le message s'ecrit sous l'etiquette.
  *
  * ⚠️ **Pour un choix a envoyer avec un formulaire.** Un reglage qui s'applique
  * IMMEDIATEMENT est un `st-switch` : la case promet un effet a l'envoi, et
  * l'interrupteur un effet tout de suite (UX-8).
+ *
+ * `indetermine` (« tout selectionner » d'une liste partiellement choisie) pose l'etat natif
+ * `indeterminate`, que le lecteur d'ecran annonce « partiellement coche » (`mixed`) ; un clic le
+ * leve et coche la case, comme le fait le navigateur.
+ *
+ * `readonly` (regle `readonly()` du schema) : la case reste focalisable et lue, mais ni le clic ni
+ * Espace ne la basculent (`ContratDeCase`).
+ *
+ * Libelle riche (lot 218) : un element `[stLibelle]` projete remplace le texte de l'etiquette, pour
+ * un lien dans la phrase. L'etiquette reste le `label` de la case, et le lien son nom accessible ;
+ * un clic sur le lien suit le lien sans cocher (un contenu interactif dans un `label` ne l'active
+ * pas). `libelle` reste obligatoire et dit la meme chose en texte : c'est lui que cite le
+ * recapitulatif d'erreurs.
+ *
+ * ```html
+ * <st-checkbox libelle="J'accepte les conditions generales" [formField]="inscription.conditions">
+ *   <span stLibelle>J'accepte les <a stLink href="/cgu">conditions generales</a></span>
+ * </st-checkbox>
+ * ```
  */
-declare class StCheckbox implements FormCheckboxControl {
-    readonly libelle: _angular_core.InputSignal<string>;
-    readonly aide: _angular_core.InputSignal<string | null>;
-    /** Contrat Signal Forms. */
-    readonly checked: _angular_core.ModelSignal<boolean>;
-    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly name: _angular_core.InputSignal<string>;
-    readonly touch: _angular_core.OutputEmitterRef<void>;
-    private readonly champ;
-    focus(options?: FocusOptions): void;
-    protected surChangement(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StCheckbox, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCheckbox, "st-checkbox", never, { "libelle": { "alias": "libelle"; "required": true; "isSignal": true; }; "aide": { "alias": "aide"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touch": "touch"; }, never, never, true, never>;
+export declare class StCheckbox extends ContratDeCase {
+  /**
+   * Etat intermediaire (« 3 sur 7 »). Un modele : la bascule par la personne le leve, et
+   * l'application le lit (`[(indetermine)]`) pour savoir que le choix est devenu franc.
+   */
+  readonly indetermine: import("@angular/core").ModelSignal<boolean>;
+  /**
+   * L'aide dit l'etat OBTENU (« Recommande · Actif », planche 3a) : une fois la case cochee, elle
+   * passe au vert de succes, en 500. A choisir explicitement : une aide ordinaire (« Un courriel
+   * vous sera envoye. ») ne prend pas la couleur du succes parce qu'on a coche.
+   */
+  readonly aideDEtat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** L'erreur se montre-t-elle ? La meme regle que le champ : apres la sortie du controle. */
+  protected readonly enErreur: import("@angular/core").Signal<boolean>;
+  protected surChangement(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCheckbox, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StCheckbox, "st-checkbox", never, {
+    "indetermine": {
+      "alias": "indetermine";
+      "required": false;
+      "isSignal": true;
+    };
+    "aideDEtat": {
+      "alias": "aideDEtat";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "indetermine": "indetermineChange";
+  }, never, ["[stLibelle]"], true, never>;
 }
-
-/** Une option du groupe. */
-interface OptionRadio {
-    readonly valeur: string;
-    readonly libelle: string;
-    /** Precision sous le libelle, reliee a l'option. */
-    readonly aide?: string;
-    readonly desactivee?: boolean;
+/**
+ * Une option du groupe : la forme d'option de toutes les listes (`OptionDeListe`), avec la RAISON
+ * d'une option desactivee, lue en aide (« Indisponible pour ce compte. ») plutot que tue.
+ */
+export interface OptionRadio extends OptionDeListe {
+  readonly raison?: string;
 }
 /**
  * Groupe de boutons radio, integre a Signal Forms.
@@ -407,44 +1167,1209 @@ interface OptionRadio {
  * groupe, deplacement aux fleches, « 2 sur 3 » annonce. Les recrire en ARIA,
  * c'est cent lignes pour obtenir moins bien — meme raison que `st-theme-toggle`.
  *
- * ⚠️ **L'erreur porte sur le groupe**, par `st-fieldset`, et non sur chaque option :
- * « Choisissez un mode de reglement », une fois.
+ * ⚠️ **Le message d'erreur porte sur le groupe**, par `st-fieldset` : « Choisissez un mode de
+ * reglement », une fois. L'ETAT d'erreur, lui, est pose sur chaque radio (`aria-invalid`) : le
+ * lecteur d'ecran le dit sur l'option ou se trouve le focus (WCAG 4.1.2), pas seulement a
+ * l'entree du groupe. Le `fieldset` est un `radiogroup` (`choixExclusif`) : c'est lui qui porte
+ * `aria-required`, `aria-invalid` et `aria-readonly`, qu'ARIA ne prevoit pas sur un radio.
+ *
+ * Chaque option est une ligne de 44 px au moins (planches 3a, 3b) : radio de 24, libelle et aide ;
+ * l'option choisie se teinte.
  *
  * `touch` n'est emis que lorsque le focus QUITTE le groupe : passer d'une option a
  * l'autre aux fleches n'est pas une fin de saisie, et l'erreur n'a pas a surgir
  * pendant qu'on choisit.
+ *
+ * `readonly` : les options restent focalisables et lues, mais le choix ne change pas (un clic ou
+ * une fleche est annule, l'option du modele reste cochee) ; le groupe l'annonce
+ * (`aria-readonly` du `radiogroup`) et le curseur reste celui par defaut.
+ */
+export declare class StRadioGroup implements FormValueControl<string> {
+  private readonly element;
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly options: import("@angular/core").InputSignal<readonly OptionRadio[]>;
+  /** `en-ligne` : options cote a cote (deux ou trois choix courts), en colonne quand la place manque. */
+  readonly disposition: import("@angular/core").InputSignal<DispositionDeGroupe>;
+  /** Contrat Signal Forms. */
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pending: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabledReasons: import("@angular/core").InputSignal<readonly WithOptionalFieldTree<DisabledReason>[]>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly radios;
+  /** Nom partage par les options : sans lui, chaque radio forme son propre groupe. */
+  private readonly nomParDefaut;
+  /** L'erreur se montre apres la sortie du groupe, comme son message. */
+  protected readonly enErreur: import("@angular/core").Signal<boolean>;
+  /** L'aide du groupe, suivie des raisons de sa desactivation. */
+  protected readonly aideEtRaisons: import("@angular/core").Signal<string | null>;
+  protected nomDuGroupe(): string;
+  protected identifiantOption(indice: number): string;
+  protected identifiantAide(indice: number): string;
+  /** L'aide d'une option : la sienne, et la raison de sa desactivation. */
+  protected aideDe(option: OptionRadio): string | null;
+  /**
+   * Focus sur l'option du MODELE, sinon la premiere active : c'est l'arret de tabulation du groupe.
+   * Lu sur l'etat (valeur et options), et non sur le DOM coche.
+   */
+  focus(options?: FocusOptions): void;
+  protected choisir(evenement: Event, valeur: string): void;
+  /** En lecture seule, le clic est annule avant que l'option ne change. */
+  protected surClic(evenement: MouseEvent): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRadioGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRadioGroup, "st-radio-group", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "dirty": {
+      "alias": "dirty";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledReasons": {
+      "alias": "disabledReasons";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/**
+ * Une option du groupe : la forme d'option de toutes les listes (`OptionDeListe`), avec la RAISON
+ * d'une option desactivee, lue en aide (« Obligatoire pour les virements. ») plutot que tue. La meme
+ * forme que `OptionRadio`.
  */
-declare class StRadioGroup implements FormValueControl<string> {
-    private readonly element;
-    readonly legende: _angular_core.InputSignal<string>;
-    readonly aide: _angular_core.InputSignal<string | null>;
-    readonly options: _angular_core.InputSignal<readonly OptionRadio[]>;
-    /** Contrat Signal Forms. */
-    readonly value: _angular_core.ModelSignal<string>;
-    readonly errors: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly name: _angular_core.InputSignal<string>;
-    readonly touch: _angular_core.OutputEmitterRef<void>;
-    /** Nom partage par les options : sans lui, chaque radio forme son propre groupe. */
-    private readonly nomParDefaut;
-    protected nomDuGroupe(): string;
-    protected identifiantAide(indice: number): string;
-    /** Focus sur l'option cochee, sinon la premiere disponible : c'est l'arret du groupe. */
-    focus(options?: FocusOptions): void;
-    protected choisir(valeur: string): void;
-    protected aLaSortie(evenement: FocusEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StRadioGroup, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StRadioGroup, "st-radio-group", never, { "legende": { "alias": "legende"; "required": true; "isSignal": true; }; "aide": { "alias": "aide"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+export interface OptionDeChoix extends OptionDeListe {
+  readonly raison?: string;
+}
+/** Ce que montre la case « Tout selectionner » : rien, une partie, ou toutes les options libres. */
+type EtatDuTout$1 = 'vide' | 'partiel' | 'coche';
+/**
+ * Groupe de cases a cocher, integre a Signal Forms : la valeur est la LISTE des options cochees.
+ *
+ * ```html
+ * <st-checkbox-group
+ *   legende="Canaux de notification"
+ *   toutSelectionner
+ *   [options]="canaux"
+ *   [formField]="preferences.canaux"
+ * />
+ * ```
+ *
+ * Le pendant multiple de `st-radio-group`, sur le meme `st-fieldset` : la legende pose la
+ * question, chaque option est une case native de 24 px sur une ligne de 44 px au moins (la hauteur
+ * de commande), avec son aide et la raison de sa desactivation.
+ *
+ * ⚠️ **Les bornes viennent du schema** : `minLength(chemin.canaux, 1)` et `maxLength(chemin.canaux,
+ * 3)` de Signal Forms comptent les options cochees ; leur message parle d'options, pas de
+ * caracteres (`messageDErreur` lit la valeur visee). Le groupe n'ajoute aucune entree de borne.
+ *
+ * ⚠️ **Le message d'erreur porte sur le groupe**, par `st-fieldset` : « Choisissez au moins
+ * 1 option. », une fois. L'ETAT d'erreur, lui, est pose sur chaque case (`aria-invalid`), comme
+ * sur chaque radio : le lecteur d'ecran le dit sur la case ou se trouve le focus (WCAG 4.1.2).
+ * L'obligation se dit dans la legende, en texte : `aria-required` sur une case voudrait dire que
+ * CETTE case doit etre cochee.
+ *
+ * `toutSelectionner` pose une case « Tout selectionner » en tete du groupe, hors de la valeur : elle
+ * est cochee quand toutes les options libres le sont, PARTIELLE (`indeterminate`, annonce
+ * « mixed ») quand une partie l'est, et nomme par `aria-controls` les cases qu'elle commande. Un
+ * clic coche toutes les options libres, ou les decoche toutes quand elles l'etaient deja. Une
+ * option desactivee garde son etat : la personne ne peut pas la changer, la case « Tout » non plus.
+ *
+ * `touch` n'est emis que lorsque le focus QUITTE le groupe : passer d'une case a l'autre n'est pas
+ * une fin de saisie, et « choisissez au moins une option » n'a pas a surgir pendant qu'on coche.
+ *
+ * `readonly` : les cases restent focalisables et lues (`aria-readonly`), mais ni le clic ni Espace
+ * ne les basculent, la case « Tout » comprise.
+ *
+ * La valeur suit l'ordre des options, quel que soit l'ordre des clics ; une valeur que les options
+ * ne connaissent pas est gardee a la fin, jamais effacee en silence.
+ */
+export declare class StCheckboxGroup implements FormValueControl<readonly string[]> {
+  private readonly element;
+  private readonly libelles;
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly options: import("@angular/core").InputSignal<readonly OptionDeChoix[]>;
+  /** `en-ligne` : cases cote a cote (deux ou trois choix courts), en colonne quand la place manque. */
+  readonly disposition: import("@angular/core").InputSignal<DispositionDeGroupe>;
+  /** Une case « Tout selectionner » en tete du groupe, partielle quand une partie est cochee. */
+  readonly toutSelectionner: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Contrat Signal Forms. */
+  readonly value: import("@angular/core").ModelSignal<readonly string[]>;
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pending: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabledReasons: import("@angular/core").InputSignal<readonly WithOptionalFieldTree<DisabledReason>[]>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly cases;
+  /** Racine des identifiants des cases et de leurs aides. */
+  private readonly racine;
+  protected readonly identifiantDuTout: string;
+  protected readonly libelleDuTout: import("@angular/core").Signal<string>;
+  /** L'erreur se montre apres la sortie du groupe, comme son message. */
+  protected readonly enErreur: import("@angular/core").Signal<boolean>;
+  private readonly choisies;
+  /** Les options que la personne peut changer : celles que la case « Tout » commande. */
+  private readonly libres;
+  protected readonly etatDuTout: import("@angular/core").Signal<EtatDuTout$1>;
+  /** Les cases que commande la case « Tout », pour `aria-controls`. */
+  protected readonly casesCommandees: import("@angular/core").Signal<string>;
+  /** L'aide du groupe, suivie des raisons de sa desactivation. */
+  protected readonly aideEtRaisons: import("@angular/core").Signal<string | null>;
+  protected estChoisie(valeur: string): boolean;
+  protected identifiantOption(indice: number): string;
+  protected identifiantAide(indice: number): string;
+  /** L'aide d'une option : la sienne, et la raison de sa desactivation. */
+  protected aideDe(option: OptionDeChoix): string | null;
+  /**
+   * Focus sur la premiere option libre (Signal Forms l'appelle pour « choisissez au moins une
+   * option ») : une case qui compte, jamais la case « Tout ».
+   */
+  focus(options?: FocusOptions): void;
+  /** En lecture seule, le clic (souris, ou Espace qui passe par lui) est annule avant la bascule. */
+  protected surClic(evenement: MouseEvent): void;
+  protected basculer(evenement: Event, valeur: string): void;
+  protected basculerTout(evenement: Event): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  /** Les valeurs dans l'ordre des options, puis celles que les options ne connaissent pas. */
+  private dansLOrdre;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCheckboxGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StCheckboxGroup, "st-checkbox-group", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "toutSelectionner": {
+      "alias": "toutSelectionner";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "dirty": {
+      "alias": "dirty";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledReasons": {
+      "alias": "disabledReasons";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/** Une ligne de la matrice : un evenement (« Operation carte »), et sa precision eventuelle. */
+export interface LigneDeMatrice {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly precision?: string;
+}
+/** Une colonne de la matrice : un canal (« Courriel »), et son icone eventuelle (decorative). */
+export interface ColonneDeMatrice {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly icone?: Icone;
+}
+/** Une cellule qu'on ne peut pas changer, et pourquoi (D39 : elle reste focalisable et le dit). */
+export interface CelluleIndisponible {
+  /** `ligne:colonne`. */
+  readonly cle: string;
+  readonly raison: string;
+}
+/**
+ * `formulaire` : la valeur part avec le formulaire (contrat Signal Forms, erreurs a la sortie).
+ * `immediat` : chaque case s'applique tout de suite (un reglage, UX-8) : aucune erreur de
+ * validation, `aria-busy` sur les cellules que l'application enregistre, et l'issue de chaque
+ * enregistrement annoncee.
+ */
+export type ModeDeMatrice = 'formulaire' | 'immediat';
+type EtatDuTout = 'vide' | 'partiel' | 'coche';
+/**
+ * Matrice de cases : des evenements en lignes, des canaux en colonnes (preferences d'alertes,
+ * droits par role, documents par canal). La valeur est la liste des cles `ligne:colonne` cochees.
+ *
+ * ```html
+ * <st-choice-matrix
+ *   legende="Alertes"
+ *   [lignes]="evenements"
+ *   [colonnes]="canaux"
+ *   toutParColonne
+ *   [formField]="preferences.alertes"
+ * />
+ * ```
+ *
+ * ⚠️ **Un tableau natif, pas une grille ARIA ni des cartes** (UX-5) : `caption` pour son nom,
+ * `th scope="col"` et `th scope="row"` : le lecteur d'ecran lit l'en-tete de ligne et de colonne en
+ * se deplacant. Chaque case porte son nom COMPLET et unique (« Operation carte, Courriel ») :
+ * quinze cases « Courriel » seraient indiscernables hors du tableau (liste des champs d'un lecteur
+ * d'ecran). Sous la largeur du tableau, il defile dans une zone NOMMEE par la legende, focalisable
+ * quand elle deborde ; il ne se transforme jamais en cartes.
+ *
+ * `toutParColonne` et `toutParLigne` posent une case « tout » dans chaque en-tete : partielle
+ * (`indeterminate`) quand une partie des cases disponibles l'est, elle coche ou decoche les cases
+ * disponibles de sa ligne ou de sa colonne. Une cellule indisponible (`cellulesIndisponibles`) reste
+ * focalisable (`aria-disabled`, D39), dit sa raison, et garde son etat.
+ *
+ * Le message d'erreur porte sur la matrice (mode `formulaire`), une fois, a la sortie de la matrice ;
+ * l'etat (`aria-invalid`) sur chaque case. `readonly` : rien ne bascule. `focus()` : la premiere case
+ * disponible.
+ *
+ * ⚠️ **Mode immediat : l'issue de l'enregistrement se dit, et elle seule.** La case native dit
+ * deja son nouvel etat a la bascule ; l'annoncer en plus le disait deux fois (audit UI du
+ * 2026-09-27, D-21). Une cellule basculee par la personne, puis posee dans `cellulesEnAttente` par
+ * l'application, se dit en en sortant : enregistree (`celluleBasculee`) si elle garde l'etat
+ * demande, refusee (`choixNonEnregistre`) si l'application l'a rendu. L'application rend donc la
+ * valeur d'avant AVANT ou AVEC la sortie de `cellulesEnAttente`. Sans `cellulesEnAttente`, rien de
+ * plus ne se dit que la case elle-meme.
+ */
+export declare class StChoiceMatrix implements FormValueControl<readonly string[]> {
+  private readonly element;
+  private readonly destruction;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly lignes: import("@angular/core").InputSignal<readonly LigneDeMatrice[]>;
+  readonly colonnes: import("@angular/core").InputSignal<readonly ColonneDeMatrice[]>;
+  readonly toutParColonne: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly toutParLigne: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly cellulesIndisponibles: import("@angular/core").InputSignal<readonly CelluleIndisponible[]>;
+  readonly mode: import("@angular/core").InputSignal<ModeDeMatrice>;
+  /** Mode `immediat` : les cles `ligne:colonne` que l'application enregistre (`aria-busy`). */
+  readonly cellulesEnAttente: import("@angular/core").InputSignal<readonly string[]>;
+  /** Contrat Signal Forms. */
+  readonly value: import("@angular/core").ModelSignal<readonly string[]>;
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pending: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabledReasons: import("@angular/core").InputSignal<readonly WithOptionalFieldTree<DisabledReason>[]>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly cases;
+  private readonly zone;
+  private readonly racine;
+  protected readonly identifiants: {
+    readonly legende: `${string}-legende`;
+    readonly aide: `${string}-aide`;
+    readonly erreur: `${string}-erreur`;
+    readonly deborde: `${string}-deborde`;
+  };
+  protected readonly annonce: AnnonceLocale;
+  /** La zone deborde : elle devient focalisable, pour defiler au clavier (UX-6). */
+  protected readonly deborde: import("@angular/core").WritableSignal<boolean>;
+  private readonly choisies;
+  private readonly indisponibles;
+  private readonly enAttente;
+  /** Mode immediat : les bascules de la personne dont l'issue n'est pas encore dite, par cle. */
+  private readonly bascules;
+  /** Les erreurs ne se disent qu'en mode formulaire, apres la sortie de la matrice. */
+  protected readonly enErreur: import("@angular/core").Signal<boolean>;
+  protected readonly messages: import("@angular/core").Signal<string[]>;
+  /** L'aide de la matrice, suivie des raisons de sa desactivation. */
+  protected readonly aideEtRaisons: import("@angular/core").Signal<string | null>;
+  /** Ce qui decrit le tableau : l'aide, le debordement, puis l'erreur. */
+  protected readonly descriptions: import("@angular/core").Signal<string | null>;
+  constructor();
+  /** Protegee : lue par la classe et son gabarit seuls, elle n'est pas de la surface (Q-17). */
+  protected cle(ligne: LigneDeMatrice, colonne: ColonneDeMatrice): string;
+  protected estCochee(ligne: LigneDeMatrice, colonne: ColonneDeMatrice): boolean;
+  protected raisonDe(ligne: LigneDeMatrice, colonne: ColonneDeMatrice): string | null;
+  protected estEnAttente(ligne: LigneDeMatrice, colonne: ColonneDeMatrice): boolean;
+  protected idColonne(indice: number): string;
+  protected idLigne(indice: number): string;
+  protected idCase(ligne: number, colonne: number): string;
+  protected idRaison(ligne: number, colonne: number): string;
+  /** Les cases disponibles d'une colonne ou d'une ligne, par leurs cles. */
+  private disponibles;
+  private clesDeColonne;
+  private clesDeLigne;
+  private etatDe;
+  protected etatDeColonne(colonne: ColonneDeMatrice): EtatDuTout;
+  protected etatDeLigne(ligne: LigneDeMatrice): EtatDuTout;
+  /** Les cases qu'une case « tout » commande, pour `aria-controls`. */
+  protected casesDeColonne(colonne: ColonneDeMatrice, indice: number): string;
+  protected casesDeLigne(ligne: LigneDeMatrice, indice: number): string;
+  /** La premiere case disponible : ce que Signal Forms appelle pour une erreur de la matrice. */
+  focus(options?: FocusOptions): void;
+  /**
+   * Le clic est annule AVANT la bascule quand rien ne doit changer : lecture seule, cellule
+   * indisponible (aucun etat coche transitoire, aucun evenement `change`).
+   */
+  protected surClic(evenement: MouseEvent, indisponible?: boolean): void;
+  protected basculer(evenement: Event, ligne: LigneDeMatrice, colonne: ColonneDeMatrice): void;
+  protected basculerColonne(evenement: Event, colonne: ColonneDeMatrice): void;
+  protected basculerLigne(evenement: Event, ligne: LigneDeMatrice): void;
+  private basculerTout;
+  /** La valeur dans l'ordre de la matrice (lignes, puis colonnes), les cles inconnues a la fin. */
+  private ecrire;
+  protected aLaSortie(evenement: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StChoiceMatrix, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StChoiceMatrix, "st-choice-matrix", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "lignes": {
+      "alias": "lignes";
+      "required": true;
+      "isSignal": true;
+    };
+    "colonnes": {
+      "alias": "colonnes";
+      "required": true;
+      "isSignal": true;
+    };
+    "toutParColonne": {
+      "alias": "toutParColonne";
+      "required": false;
+      "isSignal": true;
+    };
+    "toutParLigne": {
+      "alias": "toutParLigne";
+      "required": false;
+      "isSignal": true;
+    };
+    "cellulesIndisponibles": {
+      "alias": "cellulesIndisponibles";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "cellulesEnAttente": {
+      "alias": "cellulesEnAttente";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "dirty": {
+      "alias": "dirty";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledReasons": {
+      "alias": "disabledReasons";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, never, never, true, never>;
+}
+/**
+ * Largeur LOGIQUE d'un champ dans une rangee : sa part de la ligne, jamais des px. Un champ en px
+ * ne suit ni la police de la personne ni le reflow a 320 px ; une part, si.
+ */
+export type LargeurDeChamp = 'etroite' | 'normale' | 'large';
+/**
+ * Deux ou trois champs courts cote a cote : code postal et ville, indicatif et numero, quantite et
+ * unite.
+ *
+ * ```html
+ * <st-form-row [largeurs]="['etroite', 'large']">
+ *   <st-input libelle="Code postal" [formField]="adresse.codePostal" />
+ *   <st-input libelle="Ville" [formField]="adresse.ville" />
+ * </st-form-row>
+ * ```
+ *
+ * ⚠️ **Aucun etat, aucune semantique** : chaque champ garde son `st-form-field`, son etiquette et
+ * ses erreurs ; la rangee n'ajoute ni role ni nom. L'ordre du DOM est l'ordre de lecture et de
+ * tabulation.
+ *
+ * La rangee repasse en colonne sous la rupture `sm` de SON conteneur (30 rem), et non de l'ecran :
+ * dans une colonne etroite comme a 320 px, et quand la personne agrandit le texte a 200 % (le
+ * conteneur, mesure en rem, retrecit d'autant). Les colonnes : `colonnes` (2, 3, ou `auto`, autant
+ * que la place en laisse), ou `largeurs`, une part logique par champ ; une largeur inconnue (des px)
+ * est refusee en developpement et vaut `normale`.
+ */
+export declare class StFormRow {
+  /** `auto` : autant de colonnes que la place en laisse, 10 rem au moins chacune. */
+  readonly colonnes: import("@angular/core").InputSignal<2 | 3 | "auto">;
+  /** Une part logique par champ, dans l'ordre ; l'emporte sur `colonnes`. */
+  readonly largeurs: import("@angular/core").InputSignal<readonly LargeurDeChamp[] | null>;
+  protected readonly gabarit: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StFormRow, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StFormRow, "st-form-row", never, {
+    "colonnes": {
+      "alias": "colonnes";
+      "required": false;
+      "isSignal": true;
+    };
+    "largeurs": {
+      "alias": "largeurs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Ce qu'un `st-consent-group` offre a ses `st-consent-row` : la valeur de chaque cle, l'ecriture
+ * d'une decision, et les etats du groupe (mode, desactive, lecture seule, erreur). Une ligne hors
+ * d'un groupe n'a pas de sens (sa valeur vit dans le groupe) : elle echoue a l'injection.
+ */
+interface GroupeDeConsentements {
+  readonly mode: Signal<'formulaire' | 'immediat'>;
+  readonly desactive: Signal<boolean>;
+  readonly lectureSeule: Signal<boolean>;
+  readonly enErreur: Signal<boolean>;
+  valeurDe(cle: string): boolean | undefined;
+  ecrire(cle: string, valeur: boolean): void;
+}
+declare const ST_GROUPE_DE_CONSENTEMENTS: InjectionToken<GroupeDeConsentements>;
+/**
+ * `formulaire` : les choix partent avec le formulaire (cases, contrat Signal Forms, erreurs a la
+ * sortie). `immediat` : chaque choix s'applique tout de suite (interrupteurs, UX-8) : aucune erreur
+ * de validation ; l'application enregistre chaque `decision` et dit un refus par la ligne.
+ */
+export type ModeDeConsentement = 'formulaire' | 'immediat';
+/**
+ * Consentements et acceptations : finalites RGPD (prospection, partage, profilage), CGU a une
+ * version donnee, mandat SEPA. La valeur est un dictionnaire `cle -> accepte` ; chaque ligne est un
+ * `st-consent-row`.
+ *
+ * ```html
+ * <st-consent-group legende="Vos choix" toutAccepter toutRefuser [formField]="inscription.choix">
+ *   <st-consent-row cle="offres" titre="Offres commerciales" description="Par courriel." />
+ *   <st-consent-row cle="cgu" titre="Conditions generales" obligatoire versionDuDocument="3.2" />
+ * </st-consent-group>
+ * ```
+ *
+ * Un `st-fieldset` (la legende pose la question). `toutAccepter` et `toutRefuser` posent deux boutons
+ * de MEME POIDS (CNIL : refuser aussi simplement qu'accepter ; deux boutons secondaires, jamais un
+ * lien ni un bouton plus discret que l'autre). Ils n'agissent que sur les lignes FACULTATIVES : une
+ * ligne obligatoire (les CGU) ne s'accepte que par sa propre case, et « Tout refuser » ne la decoche
+ * pas. Le retrait d'un consentement n'exige aucune confirmation.
+ *
+ * Le message d'erreur porte sur le groupe (mode formulaire), a la sortie du groupe ; `aria-invalid`
+ * sur chaque ligne obligatoire non acceptee. `readonly` : rien ne change (les boutons restent
+ * focalisables, `aria-disabled`). `focus()` : la premiere ligne.
+ */
+export declare class StConsentGroup implements FormValueControl<Readonly<Record<string, boolean>>>, GroupeDeConsentements {
+  private readonly element;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly mode: import("@angular/core").InputSignal<ModeDeConsentement>;
+  readonly toutAccepter: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly toutRefuser: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Contrat Signal Forms. */
+  readonly value: import("@angular/core").ModelSignal<Readonly<Record<string, boolean>>>;
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pending: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabledReasons: import("@angular/core").InputSignal<readonly WithOptionalFieldTree<DisabledReason>[]>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly lignes;
+  readonly desactive: import("@angular/core").Signal<boolean>;
+  readonly lectureSeule: import("@angular/core").Signal<boolean>;
+  /** Les erreurs ne se disent qu'en mode formulaire, apres la sortie du groupe. */
+  readonly enErreur: import("@angular/core").Signal<boolean>;
+  /** L'aide du groupe, suivie des raisons de sa desactivation. */
+  protected readonly aideEtRaisons: import("@angular/core").Signal<string | null>;
+  valeurDe(cle: string): boolean | undefined;
+  ecrire(cle: string, valeur: boolean): void;
+  focus(options?: FocusOptions): void;
+  /** Les lignes FACULTATIVES seulement : une ligne obligatoire ne s'accepte que par sa case. */
+  protected toutDecider(valeur: boolean): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StConsentGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StConsentGroup, "st-consent-group", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "toutAccepter": {
+      "alias": "toutAccepter";
+      "required": false;
+      "isSignal": true;
+    };
+    "toutRefuser": {
+      "alias": "toutRefuser";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "dirty": {
+      "alias": "dirty";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledReasons": {
+      "alias": "disabledReasons";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, ["lignes"], ["*"], true, never>;
+}
+/** Ce qu'une ligne emet a chaque decision de la personne : l'application le journalise (audit). */
+export interface DecisionDeConsentement {
+  readonly cle: string;
+  readonly valeur: boolean;
+  /** La version du document que la personne a vue en decidant. */
+  readonly version: string | null;
+}
+/**
+ * Un consentement dans un `st-consent-group` : une finalite (« Offres commerciales »), les CGU a une
+ * version donnee, un mandat SEPA.
+ *
+ * ```html
+ * <st-consent-row cle="cgu" titre="Conditions generales" obligatoire versionDuDocument="3.2">
+ *   <span stLibelle>J'accepte les <a stLink href="/cgu">conditions generales</a></span>
+ * </st-consent-row>
+ * ```
+ *
+ * Une case (mode `formulaire` du groupe) ou un interrupteur (mode `immediat`, UX-8), son titre
+ * (`titre`, et un titre riche projete `[stLibelle]` pour le lien vers le document : le lien reste
+ * un arret de tabulation a part, hors de la case), sa description et la mention de version, datee
+ * par `decideLe` (« Version 3.2, acceptee le 12 septembre 2026. »), reliees a la case.
+ *
+ * ⚠️ **Jamais cochee d'office** (CNIL) : une cle a `true` sans decision enregistree (`decideLe`)
+ * ni decision de la personne dans la page s'affiche DECOCHEE, et le developpement le signale. Une
+ * ligne `obligatoire` dit « (obligatoire) » en texte ; les actions de groupe ne la touchent jamais.
+ *
+ * Mode immediat : `enregistrement` pose `aria-busy` pendant que l'application enregistre ; un
+ * `refus` (le message du serveur) remet la ligne a son etat d'avant la decision, s'affiche relie a
+ * la ligne et s'annonce (« Choix non enregistre. »). Chaque decision sort par `decision`
+ * (`{ cle, valeur, version }`) : le socle ne journalise ni n'appelle rien. L'application remet
+ * `refus` a `null` a chaque nouvelle decision : un meme message deux fois de suite ne change rien
+ * a un signal, et le second refus ne rendrait rien.
+ *
+ * ⚠️ **L'enregistrement avale toute nouvelle decision** (la case, et les actions du groupe) :
+ * `aria-disabled`, focalisable, comme la lecture seule. Une seconde decision pendant la premiere
+ * ecrasait l'etat d'avant retenu, et un refus de la premiere rendait l'etat intermediaire, qu'aucun
+ * enregistrement n'avait jamais porte. Un refus sans decision a rendre (deja rendu, ou present des
+ * l'affichage) ne s'annonce pas : il n'y a aucun choix a dire perdu (audit UI du 2026-09-27, D-10).
+ */
+export declare class StConsentRow {
+  protected readonly groupe: GroupeDeConsentements;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  readonly cle: import("@angular/core").InputSignal<string>;
+  /** Le titre en texte : le nom de la case sans titre riche, et celui du recapitulatif d'erreurs. */
+  readonly titre: import("@angular/core").InputSignal<string>;
+  readonly description: import("@angular/core").InputSignal<string | null>;
+  readonly obligatoire: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly versionDuDocument: import("@angular/core").InputSignal<string | null>;
+  /** Date de la derniere decision enregistree, `null` si la personne n'a jamais decide. */
+  readonly decideLe: import("@angular/core").InputSignal<string | null>;
+  /** Mode immediat : l'application enregistre la decision (`aria-busy`). */
+  readonly enregistrement: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Mode immediat : le refus du serveur, dit a la personne ; la ligne revient a son etat d'avant. */
+  readonly refus: import("@angular/core").InputSignal<string | null>;
+  readonly decision: import("@angular/core").OutputEmitterRef<DecisionDeConsentement>;
+  private readonly champ;
+  protected readonly identifiantDuRefus: string;
+  protected readonly annonce: AnnonceLocale;
+  /** La personne a decide dans la page : sa decision s'affiche, meme sans `decideLe`. */
+  private readonly decideeIci;
+  /** Mode immediat : la valeur d'avant la derniere decision, rendue sur un refus. */
+  private precedente;
+  protected readonly immediat: import("@angular/core").Signal<boolean>;
+  protected readonly coche: import("@angular/core").Signal<boolean>;
+  protected readonly enAttente: import("@angular/core").Signal<boolean>;
+  protected readonly enErreur: import("@angular/core").Signal<boolean>;
+  /** La description, puis la version du document et la decision datee. */
+  protected readonly aide: import("@angular/core").Signal<string | null>;
+  protected readonly descriptionsDuRefus: import("@angular/core").Signal<string[]>;
+  constructor();
+  /**
+   * Une decision de la personne (sa case, ou une action du groupe) : ecrite dans le groupe et
+   * emise. Rien en lecture seule, desactive, ni pendant l'enregistrement de la precedente :
+   * `precedente` reste l'etat d'avant la decision en cours d'enregistrement, le seul qu'un refus
+   * puisse rendre (D-10).
+   */
+  decider(valeur: boolean): void;
+  focus(options?: FocusOptions): void;
+  /** En lecture seule et pendant l'enregistrement, le clic (souris, ou Espace) est annule. */
+  protected surClic(evenement: MouseEvent): void;
+  protected surBascule(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StConsentRow, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StConsentRow, "st-consent-row", never, {
+    "cle": {
+      "alias": "cle";
+      "required": true;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": true;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "obligatoire": {
+      "alias": "obligatoire";
+      "required": false;
+      "isSignal": true;
+    };
+    "versionDuDocument": {
+      "alias": "versionDuDocument";
+      "required": false;
+      "isSignal": true;
+    };
+    "decideLe": {
+      "alias": "decideLe";
+      "required": false;
+      "isSignal": true;
+    };
+    "enregistrement": {
+      "alias": "enregistrement";
+      "required": false;
+      "isSignal": true;
+    };
+    "refus": {
+      "alias": "refus";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "decision": "decision";
+  }, never, ["[stLibelle]"], true, never>;
+}
+/**
+ * Ce qu'un `st-choice-group` offre a ses `st-choice` : le mode (radios ou cases), le nom partage
+ * par les controles, les etats du groupe, et la lecture et l'ecriture de la valeur. Une carte hors
+ * d'un groupe n'a pas de sens (sa valeur vit dans le groupe) : elle echoue a l'injection.
+ */
+interface GroupeDeChoix {
+  readonly multiple: Signal<boolean>;
+  readonly nom: Signal<string>;
+  readonly desactive: Signal<boolean>;
+  readonly lectureSeule: Signal<boolean>;
+  readonly enErreur: Signal<boolean>;
+  estChoisie(valeur: string): boolean;
+  choisir(valeur: string, coche: boolean): void;
+  /** Remet chaque controle natif a l'etat du modele, apres une bascule refusee. */
+  resynchroniser(): void;
+}
+declare const ST_GROUPE_DE_CHOIX: InjectionToken<GroupeDeChoix>;
+/** `unique` : des radios, un seul choix. `multiple` : des cases, plusieurs choix. */
+export type ModeDeChoix = 'unique' | 'multiple';
+/**
+ * La valeur d'un groupe de cartes : une chaine en mode `unique` (vide tant que rien n'est choisi),
+ * la LISTE des valeurs choisies en mode `multiple`.
+ */
+export type ChoixDeGroupe = string | readonly string[];
+/** `colonne` : les cartes l'une sous l'autre. `grille` : deux colonnes des la rupture `md`. */
+export type DispositionDeChoix = 'colonne' | 'grille';
+/**
+ * Cartes de choix : un compte a debiter, un beneficiaire, une offre, un moyen de connexion. Chaque
+ * option est un `st-choice` projete, qui porte un titre, une precision riche (`st-masked`,
+ * `st-money`), une icone ou un avatar, et un detail revele quand il est choisi.
+ *
+ * ```html
+ * <st-choice-group legende="Compte a debiter" [formField]="virement.compte">
+ *   <st-choice valeur="courant">
+ *     <st-icon nom="compte" />
+ *     Compte courant
+ *     <st-masked precision type="iban" valeur="FR76 •••• •••• •••• •••• •••• 189" />
+ *   </st-choice>
+ *   <st-choice valeur="epargne" desactivee raisonDIndisponibilite="Solde insuffisant.">
+ *     Livret d'epargne
+ *     <st-money precision [valeur]="solde" />
+ *   </st-choice>
+ * </st-choice-group>
+ * ```
+ *
+ * ⚠️ **De vrais radios ou de vraies cases, visibles** (`mode`) : un seul arret de tabulation et les
+ * fleches en mode `unique`, « 2 sur 3 » annonce, Espace coche. La carte entiere est l'ETIQUETTE du
+ * controle, jamais une carte cliquable sans nom ni clavier (UX-3) : c'est ce que le groupe
+ * remplace, et pourquoi `st-choice-card` n'existe pas.
+ *
+ * Un `st-fieldset` : la legende pose la question, l'aide la precise ; le message d'erreur porte sur
+ * le groupe, a la sortie du groupe, et l'ETAT d'erreur sur chaque controle (`aria-invalid`). En mode
+ * `unique`, le `fieldset` est un `radiogroup` qui porte l'obligation et la lecture seule (ARIA ne
+ * les prevoit pas sur un radio) ; en mode `multiple`, chaque case porte `aria-readonly`.
+ *
+ * La valeur est une chaine en mode `unique` et une liste en mode `multiple` (`ChoixDeGroupe`) : le
+ * champ lie par `[formField]` a le type de son mode, et le developpement signale une valeur de
+ * l'autre forme. En mode `multiple`, la liste suit l'ordre des cartes quel que soit l'ordre des
+ * clics ; une valeur qu'aucune carte ne porte est gardee a la fin, jamais effacee en silence. Les
+ * bornes (`minLength`, `maxLength`) viennent du schema, comme pour `st-checkbox-group`.
+ *
+ * `touch` n'est emis que lorsque le focus QUITTE le groupe. `readonly` : les cartes restent
+ * focalisables et lues, mais rien ne change. `focus()` : la carte choisie en mode `unique`, sinon
+ * la premiere disponible.
+ */
+export declare class StChoiceGroup implements FormValueControl<ChoixDeGroupe>, GroupeDeChoix {
+  private readonly element;
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly aide: import("@angular/core").InputSignal<string | null>;
+  readonly mode: import("@angular/core").InputSignal<ModeDeChoix>;
+  readonly disposition: import("@angular/core").InputSignal<DispositionDeChoix>;
+  /** Contrat Signal Forms. */
+  readonly value: import("@angular/core").ModelSignal<ChoixDeGroupe>;
+  readonly errors: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
+  readonly touched: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly dirty: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pending: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabledReasons: import("@angular/core").InputSignal<readonly WithOptionalFieldTree<DisabledReason>[]>;
+  readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly hidden: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly touch: import("@angular/core").OutputEmitterRef<void>;
+  private readonly cartes;
+  /** Nom partage par les controles : sans lui, chaque radio forme son propre groupe. */
+  private readonly nomParDefaut;
+  readonly multiple: import("@angular/core").Signal<boolean>;
+  readonly nom: import("@angular/core").Signal<string>;
+  readonly desactive: import("@angular/core").Signal<boolean>;
+  readonly lectureSeule: import("@angular/core").Signal<boolean>;
+  /** L'erreur se montre apres la sortie du groupe, comme son message. */
+  readonly enErreur: import("@angular/core").Signal<boolean>;
+  /** Les valeurs choisies, quelle que soit la forme de la valeur. */
+  private readonly choisies;
+  /** L'aide du groupe, suivie des raisons de sa desactivation. */
+  protected readonly aideEtRaisons: import("@angular/core").Signal<string | null>;
+  constructor();
+  estChoisie(valeur: string): boolean;
+  /** Une decision de la personne : en mode `unique`, seul un choix coche ecrit la valeur. */
+  choisir(valeur: string, coche: boolean): void;
+  resynchroniser(): void;
+  /**
+   * Focus sur la carte choisie (mode `unique` : c'est l'arret de tabulation du groupe), sinon sur la
+   * premiere disponible. Lu sur l'etat (valeur et cartes), et non sur le DOM coche.
+   */
+  focus(options?: FocusOptions): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  /** Les valeurs dans l'ordre des cartes, puis celles qu'aucune carte ne porte. */
+  private dansLOrdre;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StChoiceGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StChoiceGroup, "st-choice-group", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "aide": {
+      "alias": "aide";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+    "touched": {
+      "alias": "touched";
+      "required": false;
+      "isSignal": true;
+    };
+    "dirty": {
+      "alias": "dirty";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledReasons": {
+      "alias": "disabledReasons";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "touch": "touch";
+  }, ["cartes"], ["*"], true, never>;
+}
+/**
+ * Une carte de choix dans un `st-choice-group` : un radio (mode `unique`) ou une case (mode
+ * `multiple`) natifs et visibles, que la carte entiere etiquette.
+ *
+ * ```html
+ * <st-choice valeur="courant">
+ *   <st-icon nom="compte" />
+ *   Compte courant
+ *   <st-masked precision type="iban" valeur="FR76 •••• •••• •••• •••• •••• 189" />
+ *   <div detail><st-input libelle="Reference du virement" /></div>
+ * </st-choice>
+ * ```
+ *
+ * Projections : le TITRE (contenu par defaut), la PRECISION (`[precision]` : `st-masked`,
+ * `st-money`, un texte discret), une icone ou un avatar (`st-icon`, `st-avatar`), et le DETAIL
+ * (`[detail]`), revele sous la carte tant qu'elle est choisie (motif « conditional reveal » de
+ * GOV.UK, dans le flux, jamais dans un dialogue).
+ *
+ * ⚠️ Le nom du controle est le texte de son etiquette : le titre, puis la precision (`st-masked`
+ * y donne « IBAN se terminant par 0189 »). L'etiquette ne contient donc AUCUN autre controle :
+ * pas de `st-masked` a bouton de revelation (`charger`), pas de lien. Ce qui se manipule va dans
+ * le detail, hors de l'etiquette.
+ *
+ * Le detail est relie au controle par `aria-controls` ; une case porte aussi `aria-expanded`
+ * (ARIA ne le prevoit pas sur un radio). Le focus n'y est jamais deplace d'office (WCAG 3.2.2) :
+ * il suit la carte dans l'ordre de tabulation, et n'y entre que visible.
+ *
+ * `desactivee` : la carte reste FOCALISABLE (`aria-disabled`, D39, comme une cellule de
+ * `st-choice-matrix`), dit sa raison (`raisonDIndisponibilite`, reliee par `aria-describedby`) et
+ * ne se choisit pas. Le groupe desactive (le schema) gele toutes ses cartes nativement.
+ */
+export declare class StChoice {
+  protected readonly groupe: GroupeDeChoix;
+  readonly valeur: import("@angular/core").InputSignal<string>;
+  /** La carte ne se choisit pas, mais reste focalisable et dit pourquoi (D39). */
+  readonly desactivee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Pourquoi la carte ne se choisit pas : lu avec le controle, affiche sous la carte. */
+  readonly raisonDIndisponibilite: import("@angular/core").InputSignal<string | null>;
+  private readonly controle;
+  private readonly zoneDuDetail;
+  private readonly racine;
+  protected readonly identifiantDeLaRaison: string;
+  protected readonly identifiantDuDetail: string;
+  protected readonly coche: import("@angular/core").Signal<boolean>;
+  /** La raison ne se dit que d'une carte indisponible. */
+  protected readonly raison: import("@angular/core").Signal<string | null>;
+  /** Un detail est projete : le controle le designe (`aria-controls`). */
+  protected readonly aUnDetail: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  focus(options?: FocusOptions): void;
+  /** Remet le controle natif a l'etat du modele (le groupe l'appelle apres une bascule refusee). */
+  resynchroniser(): void;
+  private immobile;
+  /**
+   * Le clic est annule AVANT la bascule quand rien ne doit changer (lecture seule, carte
+   * indisponible). Chromium rend alors la coche a l'option du modele, mais pas tous les moteurs
+   * (jsdom ne restaure que le radio clique) : le groupe la rend lui-meme, l'evenement retombe.
+   */
+  protected surClic(evenement: MouseEvent): void;
+  protected surBascule(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StChoice, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StChoice, "st-choice", never, {
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "desactivee": {
+      "alias": "desactivee";
+      "required": false;
+      "isSignal": true;
+    };
+    "raisonDIndisponibilite": {
+      "alias": "raisonDIndisponibilite";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["st-icon, st-avatar", "*", "[precision]", "[detail]"], true, never>;
 }
-
 /**
  * Interrupteur : un reglage qui s'applique IMMEDIATEMENT.
  *
  * ```html
- * <st-switch libelle="Notifications par SMS" [(checked)]="sms" (checkedChange)="enregistrer($event)" />
+ * <st-switch libelle="Notifications par SMS" libelleEtat [(checked)]="sms" (checkedChange)="enregistrer($event)" />
  * ```
  *
  * ⚠️ **Jamais dans un formulaire a envoyer** (UX-8). Un interrupteur promet que
@@ -454,83 +2379,233 @@ declare class StRadioGroup implements FormValueControl<string> {
  *
  * C'est pourquoi il n'affiche aucune erreur de validation : un reglage immediat
  * ne se valide pas a l'envoi. Un refus du serveur se dit par un message, et
- * l'interrupteur revient a son etat precedent.
+ * l'interrupteur revient a son etat precedent. Une regle du schema posee sur lui (`required`,
+ * `validate`) bloquerait pourtant l'envoi d'un formulaire sans rien montrer : en developpement,
+ * il le signale une fois dans la console.
  *
  * ⚠️ Une case a cocher native avec `role="switch"` : Espace bascule, l'etiquette
  * est reliee par `for`, et le lecteur d'ecran annonce « active » ou
  * « desactive » — mieux qu'un `div` qui imiterait tout cela.
+ *
+ * Une ligne de reglage (planches 3a, 3b) : l'etiquette et son etat a gauche, le rail de 44 x 24 a
+ * droite (a gauche en RTL). `libelleEtat` ecrit l'etat en mots sous l'etiquette (« Etat :
+ * Active », en vert ; « Etat : Desactive ») : la position d'un curseur n'est pas lue par tous.
+ *
+ * Enregistrement en attente (03 §3.3) : `enAttente` pose `aria-busy` sur le
+ * controle pendant que l'appelant enregistre, et remplace l'aide par « Enregistrement en cours… »
+ * (ou `libelleAttente`), relie au controle. Le curseur est DEJA a sa nouvelle position
+ * (optimiste) ; sur un refus, l'appelant remet `checked` et dit pourquoi.
+ *
+ * ⚠️ **L'attente avale toute nouvelle bascule** (`aria-disabled`, focalisable, comme la lecture
+ * seule) : une seconde bascule partait pendant la premiere, et le retour d'un refus ne savait plus
+ * quel etat rendre. Un `checked` remis par l'appelant pendant l'attente, ou en la levant, est un
+ * refus : le curseur revenait en silence, il s'annonce (`choixNonEnregistre`, comme
+ * `st-consent-row`). Aboutie, l'attente ne dit rien : l'etat obtenu s'est dit a la bascule (audit
+ * UI du 2026-09-27, D-10).
  */
-declare class StSwitch implements FormCheckboxControl {
-    readonly libelle: _angular_core.InputSignal<string>;
-    readonly aide: _angular_core.InputSignal<string | null>;
-    /** Contrat Signal Forms. */
-    readonly checked: _angular_core.ModelSignal<boolean>;
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    readonly name: _angular_core.InputSignal<string>;
-    readonly touch: _angular_core.OutputEmitterRef<void>;
-    private readonly champ;
-    focus(options?: FocusOptions): void;
-    protected surChangement(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSwitch, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSwitch, "st-switch", never, { "libelle": { "alias": "libelle"; "required": true; "isSignal": true; }; "aide": { "alias": "aide"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touch": "touch"; }, never, never, true, never>;
+export declare class StSwitch extends ContratDeCase {
+  private readonly libelles;
+  protected readonly annonce: AnnonceLocale;
+  /**
+   * Le reglage s'enregistre : `aria-busy`, curseur d'attente ; le controle reste focalisable, et
+   * avale toute nouvelle bascule jusqu'a la fin de l'attente.
+   */
+  readonly enAttente: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le texte de l'attente ; `null` : « Enregistrement en cours… », du dictionnaire. */
+  readonly libelleAttente: import("@angular/core").InputSignal<string | null>;
+  /**
+   * L'aide dit l'etat OBTENU (« Actif · Chiffrement HSM », planche 3a) : actif, elle passe au vert
+   * de succes, en 500. A choisir explicitement, comme sur `st-checkbox`.
+   */
+  readonly aideDEtat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Ecrit l'etat en mots sous l'etiquette (« Etat : Active » / « Etat : Desactive »). */
+  readonly libelleEtat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  /** En attente, une nouvelle bascule est annulee AVANT d'avoir lieu, comme en lecture seule. */
+  protected surClic(evenement: MouseEvent): void;
+  /** Filet si le clic passe malgre tout : en attente, la case reprend l'etat du modele. */
+  protected surBascule(evenement: Event): void;
+  /** Pendant l'attente, l'aide cede la place au texte d'attente. */
+  protected readonly aideAffichee: import("@angular/core").Signal<string | null>;
+  /** La ligne d'etat, s'il y en a une : l'attente, sinon l'etat en mots. */
+  protected readonly etat: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSwitch, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSwitch, "st-switch", never, {
+    "enAttente": {
+      "alias": "enAttente";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleAttente": {
+      "alias": "libelleAttente";
+      "required": false;
+      "isSignal": true;
+    };
+    "aideDEtat": {
+      "alias": "aideDEtat";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleEtat": {
+      "alias": "libelleEtat";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
+/**
+ * Ce qu'un formulaire dit de son envoi a ce qu'il contient (lot 247). Fourni par `form[stForm]`
+ * (`@starterlib/ui/formulaires`) ; le `st-error-summary` qu'il contient le lit, et n'a alors rien
+ * a lier. Une application qui ecrit sa propre directive de formulaire peut le fournir a son tour.
+ */
+export interface EtatDEnvoi {
+  /**
+   * Les erreurs a recapituler : aucune avant la premiere tentative, pendant l'envoi, ni apres un
+   * envoi reussi.
+   */
+  readonly recapitulatif: Signal<readonly ValidationError.WithOptionalFieldTree[]>;
+  /** Les tentatives depuis le dernier envoi reussi : chacune ramene le focus au recapitulatif. */
+  readonly tentative: Signal<number>;
+  /** Un envoi court. */
+  readonly enCours: Signal<boolean>;
+}
+export declare const ST_ETAT_D_ENVOI: InjectionToken<EtatDEnvoi>;
+/** Niveau du titre du recapitulatif, selon sa place dans la page. */
+export type NiveauDeRecapitulatif = 2 | 3 | 4;
 /** Une ligne du recapitulatif. */
 interface LigneDErreur {
-    readonly libelle: string | null;
-    readonly message: string;
-    readonly aller: () => void;
+  /** Cle stable : le champ, ou le rang d'une erreur de formulaire entier. */
+  readonly cle: unknown;
+  /** « Montant du virement : », ponctuation de la langue ; `null` pour une ligne sans champ. */
+  readonly libelle: string | null;
+  readonly message: string;
+  readonly aller: () => void;
 }
 /**
  * Recapitulatif des erreurs d'un formulaire, a l'envoi.
  *
+ * Dans un `form[stForm]` (`@starterlib/ui/formulaires`, lot 247), il n'a rien a lier : le
+ * formulaire lui fournit ses erreurs et ses tentatives.
+ *
  * ```html
- * <st-error-summary [erreurs]="tentative() ? virement().errorSummary() : []" />
+ * <form [stForm]="virement" [envoyerAvec]="envoyer">
+ *   <st-error-summary />
+ *   ...
+ * </form>
  * ```
  *
- * ⚠️ **Il prend le focus en apparaissant** (UX-5). Sans lui, une personne au
- * clavier ou au lecteur d'ecran appuie sur « Envoyer », et rien ne se passe : le
- * champ refuse est en haut de la page, hors de sa vue, et personne ne le lui dit.
+ * Hors d'un tel formulaire (en tete de page, loin du formulaire), il se lie :
+ *
+ * ```html
+ * <st-error-summary [erreurs]="formulaire.recapitulatif()" [tentative]="formulaire.tentative()" />
+ * ```
+ *
+ * ⚠️ **Il prend le focus en apparaissant, ET a chaque nouvelle tentative** (UX-5). Sans lui, une
+ * personne au clavier ou au lecteur d'ecran appuie sur « Envoyer », et rien ne se passe : le
+ * champ refuse est en haut de la page, hors de sa vue, et personne ne le lui dit. Un second envoi
+ * refuse (meme avec le meme nombre d'erreurs) incremente `tentative` : le focus revient au cadre
+ * sans que l'application appelle `focus()`. Il ne le reprend PAS a chaque correction : ce serait
+ * arracher la personne au champ qu'elle corrige.
  *
  * ⚠️ **Chaque ligne nomme son champ.** « Ce champ est obligatoire. » repete cinq
  * fois n'apprend rien ; « Nom du beneficiaire : ce champ est obligatoire. », si.
- * Le libelle est lu sur l'element lie au champ, par Signal Forms — sans registre,
- * et quel que soit le composant.
+ * Le libelle est celui du champ LIE (son `st-form-field` direct, sinon son etiquette native, sinon
+ * `aria-label`) ; un champ sans nom lisible donne quand meme un lien (« Champ 2 »).
  *
  * ⚠️ **Une ligne par champ**, la premiere erreur seulement : trois erreurs sur le
  * meme IBAN font trois lignes pour une seule correction.
  *
- * ⚠️ **Une region nommee par son titre.** Un `div` sans role ne PEUT pas porter
- * `aria-labelledby` : le nom serait ignore, et le focus n'annoncerait rien. En
- * region, il annonce « 2 erreurs a corriger » a l'arrivee du focus, et se
- * retrouve dans la liste des reperes.
- *
- * Chaque ligne amene le focus sur son champ : c'est le champ, et non la ligne,
- * qu'il faut corriger. Une erreur rattachee au formulaire entier — un refus du
- * serveur sur un champ inconnu — s'affiche sans lien.
- */
-declare class StErrorSummary {
-    private readonly libelles;
-    private readonly locale;
-    private readonly element;
-    private readonly injecteur;
-    readonly erreurs: _angular_core.InputSignal<readonly ValidationError.WithOptionalFieldTree[]>;
-    /** `null` : « N erreurs a corriger », du dictionnaire. */
-    readonly titre: _angular_core.InputSignal<string | null>;
-    /** Unique par instance : deux recapitulatifs sur une page partageraient leur titre. */
-    protected readonly identifiantDuTitre: string;
-    protected readonly lignes: _angular_core.Signal<readonly LigneDErreur[]>;
-    protected readonly titreLu: _angular_core.Signal<string>;
-    constructor();
-    /** A appeler apres un envoi refuse, quand le recapitulatif etait deja visible. */
-    focus(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StErrorSummary, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StErrorSummary, "st-error-summary", never, { "erreurs": { "alias": "erreurs"; "required": true; "isSignal": true; }; "titre": { "alias": "titre"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+ * ⚠️ **Une region nommee par son titre.** L'hote est la region focalisee : le focus annonce
+ * « 3 erreurs a corriger » a l'arrivee, et la region se retrouve dans la liste des reperes. Ni
+ * `alert` ni `aria-live` : c'est le focus qui annonce.
+ *
+ * Anatomie (planche 3b) : icone, titre (`niveau` 2 a 4), etiquette projetee `[stEtiquette]` a
+ * droite (« Blocage »), `introduction` facultative, puis une ligne par erreur. Chaque ligne amene
+ * le focus sur son champ : c'est le champ, et non la ligne, qu'il faut corriger. Une erreur
+ * rattachee au formulaire entier — un refus du serveur sur un champ inconnu — s'affiche sans lien.
+ */
+export declare class StErrorSummary {
+  private readonly libelles;
+  private readonly locale;
+  private readonly element;
+  private readonly injecteur;
+  private readonly envoi;
+  /**
+   * Les erreurs a recapituler. A omettre dans un `form[stForm]`, qui les fournit avec ses
+   * tentatives ; liees, elles l'emportent, et `tentative` se lie avec elles.
+   */
+  readonly erreurs: import("@angular/core").InputSignal<readonly ValidationError.WithOptionalFieldTree[] | undefined>;
+  /** `null` : « N erreurs a corriger », du dictionnaire. */
+  readonly titre: import("@angular/core").InputSignal<string | null>;
+  /** Niveau du titre : 2 en tete de page, 3 ou 4 dans une section ou un dialogue. */
+  readonly niveau: import("@angular/core").InputSignal<NiveauDeRecapitulatif>;
+  /** Phrase d'introduction sous le titre (« Cliquez sur une anomalie pour aller au champ. »). */
+  readonly introduction: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Compteur d'envois refuses, tenu par l'application (ou `form[stForm]`) : chaque changement
+   * ramene le focus au recapitulatif, meme quand ses lignes n'ont pas change.
+   *
+   * ⚠️ Un NOMBRE, jamais un booleen : `[tentative]="aEnvoye()"` resterait `true` au second envoi
+   * (aucun retour du focus). Le type refuse le booleen a la compilation ; une valeur illisible
+   * (chaine vide, `NaN`) vaut 0, et la comparaison par `Object.is` ne voit pas `NaN` changer.
+   */
+  readonly tentative: import("@angular/core").InputSignalWithTransform<number, number | `${number}`>;
+  /** Les erreurs lues : celles liees, sinon celles du formulaire qui l'entoure. */
+  private readonly erreursLues;
+  /** La tentative lue : celle du formulaire qui l'entoure, quand les erreurs viennent de lui. */
+  private readonly tentativeLue;
+  /** Unique par instance : deux recapitulatifs sur une page partageraient leur titre. */
+  protected readonly identifiantDuTitre: string;
+  protected readonly lignes: import("@angular/core").Signal<readonly LigneDErreur[]>;
+  protected readonly titreLu: import("@angular/core").Signal<string>;
+  constructor();
+  /** Amene le focus sur le recapitulatif (s'il est visible). */
+  focus(options?: FocusOptions): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StErrorSummary, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StErrorSummary, "st-error-summary", never, {
+    "erreurs": {
+      "alias": "erreurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "niveau": {
+      "alias": "niveau";
+      "required": false;
+      "isSignal": true;
+    };
+    "introduction": {
+      "alias": "introduction";
+      "required": false;
+      "isSignal": true;
+    };
+    "tentative": {
+      "alias": "tentative";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stEtiquette]"], true, never>;
 }
-
 /** `connexion` : un mot de passe existant. `creation` : un nouveau. */
-type UsageDuMotDePasse = 'connexion' | 'creation';
+export type UsageDuMotDePasse = 'connexion' | 'creation';
+/**
+ * Une regle de creation, montree AVANT la saisie. `respectee` la coche pendant la frappe ; sans
+ * elle, la regle reste a respecter (le serveur juge, SEC-5).
+ */
+export interface RegleDeMotDePasse {
+  /** Une phrase complete, avec son point : « Au moins 12 caracteres. » */
+  readonly texte: string;
+  readonly respectee?: (motDePasse: string) => boolean;
+}
+/** Une regle telle que le gabarit la rend. */
+interface RegleRendue {
+  readonly texte: string;
+  readonly respectee: boolean;
+}
 /**
  * Mot de passe, avec revelation.
  *
@@ -546,41 +2621,88 @@ type UsageDuMotDePasse = 'connexion' | 'creation';
  * pousse vers des mots de passe courts, retenus de tete, et casse les
  * gestionnaires de mots de passe.
  *
- * ⚠️ **Revele, il se remasque des que le focus quitte le champ, et a l'envoi du
- * formulaire** (SEC-4) : un mot de passe laisse en clair reste lisible par-dessus
- * l'epaule, sur l'ecran suivant comme sur celui-ci. L'envoi par Entree ne fait
- * pas quitter le champ : d'ou l'ecoute de `submit`, qui remonte jusqu'au document.
+ * ⚠️ **Revele, il se remasque des que le focus quitte le champ, a l'envoi du
+ * formulaire et avant l'impression** (SEC-4) : un mot de passe laisse en clair reste lisible
+ * par-dessus l'epaule, sur l'ecran suivant comme sur celui-ci, et sur le papier. L'envoi par
+ * Entree ne fait pas quitter le champ : d'ou l'ecoute de `submit`, UNE pour toute la page
+ * (`EnvoisDeFormulaire`), et non une par champ.
+ *
+ * Le bouton de revelation est un bouton bascule DANS le cadre du champ (planche 3a) :
+ * `aria-pressed` porte l'etat, et l'etiquette ne change PAS — « Masquer le mot de passe,
+ * enfonce » se lirait comme une double negation. En lecture seule, il est desactive : on ne
+ * revele pas ce qu'on ne peut pas modifier.
  *
- * Le bouton de revelation est un bouton bascule : `aria-pressed` porte l'etat, et
- * l'etiquette ne change PAS — « Masquer le mot de passe, enfonce » se lirait
- * comme une double negation.
+ * ⚠️ **Verrouillage des majuscules** : dit SOUS le champ (ton avertissement, icone et texte,
+ * jamais la couleur seule) et annonce une fois (WCAG 4.1.3). Le champ, lui, ne bouge pas ; a la
+ * creation, la ligne du message est reservee entre le champ et les regles, qui ne sautent pas.
  *
  * ⚠️ **Aucun indicateur de « force »**, et c'est un refus. Une estimation faite
  * dans le navigateur donne « fort » a `Motdepasse1!` : elle rassure a tort. Les
- * regles sont affichees AVANT la saisie (UX-10), et c'est le serveur qui verifie —
- * y compris contre les mots de passe deja divulgues, qu'aucune regle locale ne
- * voit.
- */
-declare class StPasswordField extends ControleDeSaisie {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    private readonly element;
-    readonly usage: _angular_core.InputSignal<UsageDuMotDePasse>;
-    /** Regles affichees avant la saisie, comme aide du champ. */
-    readonly regles: _angular_core.InputSignal<readonly string[]>;
-    protected readonly revele: _angular_core.WritableSignal<boolean>;
-    protected readonly autocomplete: _angular_core.Signal<"current-password" | "new-password">;
-    protected readonly aideLue: _angular_core.Signal<string | null>;
-    protected basculer(): void;
-    protected surSaisie(evenement: Event): void;
-    protected aLEnvoi(evenement: Event): void;
-    protected aLaSortie(evenement: FocusEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StPasswordField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StPasswordField, "st-password-field", never, { "usage": { "alias": "usage"; "required": false; "isSignal": true; }; "regles": { "alias": "regles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+ * regles sont affichees AVANT la saisie (UX-10), en liste, a la creation seulement, et
+ * chacune se coche quand la saisie la respecte ; c'est le serveur qui verifie — y compris
+ * contre les mots de passe deja divulgues, qu'aucune regle locale ne voit.
+ *
+ * `maxLength` du schema montre un compteur (« 12 caracteres restants ») en complement.
+ */
+export declare class StPasswordField extends ControleDeSaisie {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly element;
+  protected readonly annonce: AnnonceLocale;
+  private readonly racineDesParties;
+  protected readonly idRegles: string;
+  protected readonly idMajuscules: string;
+  readonly usage: import("@angular/core").InputSignal<UsageDuMotDePasse>;
+  /**
+   * Regles de creation, montrees sous le champ en `usage="creation"` seulement : une phrase
+   * seule, ou une phrase et le test qui la coche.
+   */
+  readonly regles: import("@angular/core").InputSignal<readonly (string | RegleDeMotDePasse)[]>;
+  /** Titre de la liste des regles ; par defaut « Exigences du mot de passe : ». */
+  readonly titreDesRegles: import("@angular/core").InputSignal<string | null>;
+  protected readonly revele: import("@angular/core").WritableSignal<boolean>;
+  /** La touche Verr. Maj est active pendant la frappe dans le champ. */
+  protected readonly majusculesVerrouillees: import("@angular/core").WritableSignal<boolean>;
+  protected readonly autocomplete: import("@angular/core").Signal<"new-password" | "current-password">;
+  protected readonly reglesRendues: import("@angular/core").Signal<readonly RegleRendue[]>;
+  protected readonly titreRendu: import("@angular/core").Signal<string>;
+  /** « 12 caracteres restants », quand le schema borne la longueur. */
+  protected readonly compteur: import("@angular/core").Signal<string | null>;
+  /** Les regles et l'avertissement Verr. Maj decrivent le champ : lus au focus, apres l'aide. */
+  protected readonly descriptionsDuControle: import("@angular/core").Signal<string[]>;
+  constructor();
+  protected basculer(): void;
+  protected surSaisie(evenement: Event): void;
+  /** Lit Verr. Maj a chaque touche : l'etat se voit des la premiere frappe, et s'annonce. */
+  protected surTouche(evenement: KeyboardEvent): void;
+  protected remasquer(): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPasswordField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StPasswordField, "st-password-field", never, {
+    "usage": {
+      "alias": "usage";
+      "required": false;
+      "isSignal": true;
+    };
+    "regles": {
+      "alias": "regles";
+      "required": false;
+      "isSignal": true;
+    };
+    "titreDesRegles": {
+      "alias": "titreDesRegles";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
 }
-
 /**
  * Code a usage unique : second facteur, code recu par SMS ou par courriel.
  *
+ * ```html
+ * <st-otp-field libelle="Code recu par SMS" [formField]="verification.code" />
+ * <!-- schema : validate(chemin.code, ({ value }) => erreurCode(value(), 6)) -->
+ * ```
+ *
  * ⚠️ **UN seul champ, pas six cases** (UX-9). Six champs cassent le collage, le
  * remplissage automatique du code recu par SMS, et la lecture au lecteur d'ecran,
  * qui annonce six champs sans nom au lieu d'un seul.
@@ -591,45 +2713,126 @@ declare class StPasswordField extends ControleDeSaisie {
  *
  * ⚠️ **Aucun envoi automatique** a la sixieme saisie : un formulaire qui part de
  * lui-meme surprend (WCAG 3.2.2), et part aussi avec un code mal colle. Le code
- * colle est nettoye de ses espaces et tirets — « 123 456 » —, jamais tronque.
+ * colle est nettoye de tout ce qui n'est pas un chiffre — « 123 456 », un tiret, un caractere
+ * invisible colle avec le SMS — ; un chiffre d'une autre ecriture (clavier arabe, pleine chasse
+ * d'un IME) est lu comme son chiffre ASCII, pas avale. Jamais tronque (aucun `maxlength`) : un code trop long se voit
+ * et se dit (`erreurCode`), il ne part pas ampute.
+ *
+ * Le renvoi du code est projete a droite du champ (`[stRenvoi]` : un `st-timer`, un lien) : le
+ * composant ne l'envoie jamais lui-meme.
+ *
+ * Chasse fixe a zero barre, 700, centree, un pas d'espacement entre chiffres (planches 3 et 8) :
+ * six chiffres qui se comptent d'un regard, sans six cases. Le champ reste de gauche a droite en
+ * ecriture inverse.
  */
-declare class StOtpField extends ControleDeSaisie {
-    private readonly libelles;
-    readonly longueur: _angular_core.InputSignal<number>;
-    protected readonly aideLue: _angular_core.Signal<string>;
-    protected surSaisie(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StOtpField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StOtpField, "st-otp-field", never, { "longueur": { "alias": "longueur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class StOtpField extends ControleDeSaisie {
+  private readonly libelles;
+  /** Nombre de chiffres attendus : il ecrit l'aide (« Code a 6 chiffres. »). */
+  readonly longueur: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Identifiants d'autres textes qui decrivent le champ (`aria-describedby`), lus entre l'aide et
+   * l'erreur : les essais restants de `st-challenge` (audit UI du 2026-09-27, D-20). Des elements
+   * PRESENTS seulement : un identifiant absent fait ignorer toute la description par certains
+   * lecteurs d'ecran.
+   */
+  readonly decritPar: import("@angular/core").InputSignal<readonly string[]>;
+  protected readonly aideLue: import("@angular/core").Signal<string>;
+  protected surSaisie(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StOtpField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StOtpField, "st-otp-field", never, {
+    "longueur": {
+      "alias": "longueur";
+      "required": false;
+      "isSignal": true;
+    };
+    "decritPar": {
+      "alias": "decritPar";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stMeta]", "[stAide]", "[stIndication]", "[stRenvoi]"], true, never>;
 }
-
 /**
  * Champ de recherche : un repere, un champ, un bouton.
  *
  * ```html
  * <st-search-field libelle="Rechercher un beneficiaire" (recherche)="filtrer($event)" />
+ * <!-- Barre de filtres (planches 4 et 10) : sans bouton, etiquette visible, raccourci. -->
+ * <st-search-field compact libelleVisible presentation="micro-capitales" libelle="Recherche"
+ *   [(value)]="terme"><kbd stRaccourci>⌘K</kbd></st-search-field>
  * ```
  *
- * ⚠️ **Un repere `search`** : la recherche se retrouve dans la liste des reperes du
- * lecteur d'ecran, a cote de la navigation et du contenu.
+ * ⚠️ **Un repere `search` NOMME** (`aria-label` = `libelle`) : deux recherches d'une page se
+ * distinguent dans la liste des reperes du lecteur d'ecran.
  *
  * L'etiquette est lue sans etre affichee — seule exception au socle (UX-1) : la
- * loupe, le bouton et la position disent deja le but du champ.
+ * loupe, le bouton et la position disent deja le but du champ. `libelleVisible` l'affiche
+ * (barre de filtres, ou chaque filtre porte son etiquette).
+ *
+ * La croix « Effacer la recherche » est celle du socle, atteignable au clavier : celle de
+ * WebKit n'etait ni stylee ni tabulable. Echap vide aussi le champ (comportement natif de
+ * `type="search"`).
+ *
+ * ⚠️ **Recherche en cours** : `chargement` passe au BOUTON (`aria-busy`, indicateur differe),
+ * jamais `disabled` — le focus ne tombe pas au milieu de l'attente. En `compact`, sans bouton,
+ * l'indicateur du socle prend la place de la loupe, avec le meme rythme que celui du bouton
+ * (rien avant `rythme.delai.attente`, puis au moins la tenue minimale) et MUET : une barre de
+ * filtres cherche a chaque Entree, et « Chargement en cours » y etait dit a chaque fois, avant
+ * les resultats que l'application annonce (audit UI du 2026-09-27, D-13).
  *
  * ⚠️ **Jamais dans l'adresse quand le terme est personnel** (SEC-6). Chercher un
  * nom, un IBAN ou un numero en `?q=` inscrit la donnee dans l'historique, dans les
  * journaux des intermediaires, et dans l'en-tete `Referer` des pages suivantes.
  * `recherche` emet le terme : c'est a l'appelant de ne pas le mettre dans l'URL.
  */
-declare class StSearchField extends ControleDeSaisie {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    /** Emis a la validation — Entree ou bouton —, et non a chaque frappe. */
-    readonly recherche: _angular_core.OutputEmitterRef<string>;
-    protected surSaisie(evenement: Event): void;
-    protected lancer(evenement?: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSearchField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSearchField, "st-search-field", never, {}, { "recherche": "recherche"; }, never, never, true, never>;
+export declare class StSearchField extends ControleDeSaisie {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly saisie;
+  /** Sans bouton « Rechercher » : Entree lance (barres de filtres, planches 4, 10, 12, 14, 15). */
+  readonly compact: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Etiquette affichee au-dessus du champ (barre de filtres) ; lue dans tous les cas. */
+  readonly libelleVisible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Style de l'etiquette affichee : `micro-capitales` dans une barre de filtres (EA-90). */
+  readonly presentation: import("@angular/core").InputSignal<PresentationDeLibelle>;
+  /**
+   * Recherche en cours : le bouton attend (`aria-busy`), il n'est jamais desactive ; en `compact`,
+   * un indicateur muet remplace la loupe.
+   */
+  readonly chargement: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Emis a la validation — Entree ou bouton —, et non a chaque frappe. */
+  readonly recherche: import("@angular/core").OutputEmitterRef<string>;
+  /** L'indicateur compact, differe et tenu : une reponse en 150 ms ne fait rien clignoter. */
+  protected readonly attenteVisible: import("@angular/core").Signal<boolean>;
+  protected surSaisie(evenement: Event): void;
+  protected lancer(evenement?: Event): void;
+  /** La croix vide le champ et rend le focus au champ : la saisie reprend la ou elle etait. */
+  protected effacer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSearchField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSearchField, "st-search-field", never, {
+    "compact": {
+      "alias": "compact";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleVisible": {
+      "alias": "libelleVisible";
+      "required": false;
+      "isSignal": true;
+    };
+    "presentation": {
+      "alias": "presentation";
+      "required": false;
+      "isSignal": true;
+    };
+    "chargement": {
+      "alias": "chargement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "recherche": "recherche";
+  }, never, ["[stRaccourci]"], true, never>;
 }
-
 /**
  * IBAN. La valeur du modele est NORMALISEE — sans espaces, en majuscules —, et
  * l'affichage groupe par quatre.
@@ -637,94 +2840,115 @@ declare class StSearchField extends ControleDeSaisie {
  * ```html
  * <st-iban-field libelle="IBAN du beneficiaire" [formField]="virement.iban" />
  * <!-- schema : validate(chemin.iban, ({ value }) => erreurIban(value())) -->
+ * <!-- un IBAN deja connu, masque au repos : -->
+ * <st-iban-field libelle="IBAN du compte" masque readonly [value]="compte.iban" />
  * ```
  *
  * ⚠️ **Le groupement se fait a la sortie du champ, jamais pendant la frappe.**
  * Reformater a chaque caractere deplace le curseur a la fin : corriger une
  * erreur au milieu de 27 caracteres devient impossible, chaque frappe renvoyant a
- * la fin de la ligne.
+ * la fin de la ligne. Le changement de forme s'annonce (« IBAN : FR76 3000 … »).
  *
  * ⚠️ **Aucune verification de validite ici** : elle appartient au schema, par
  * `erreurIban`, pour s'afficher au bon moment et par le bon canal. Et elle reste un
  * confort (SEC-5) : le serveur revalide.
  *
- * `autocapitalize="characters"` et correction orthographique coupee : un IBAN
- * n'est pas un mot, et une correction automatique le fausserait.
- */
-declare class StIbanField extends ControleDeSaisie {
-    private readonly libelles;
-    private readonly enSaisie;
-    private readonly brut;
-    protected readonly aideLue: _angular_core.Signal<string>;
-    /**
-     * Brut pendant la saisie ; groupe par quatre au repos. Une valeur changee de
-     * l'exterieur pendant la saisie — remise a zero du formulaire — l'emporte sur
-     * le brut, qui ne la represente plus.
-     */
-    protected readonly affichage: _angular_core.Signal<string>;
-    protected auFocus(): void;
-    protected surSaisie(evenement: Event): void;
-    protected aLaSortie(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StIbanField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StIbanField, "st-iban-field", never, {}, {}, never, never, true, never>;
-}
-
-/** `tel` : numero complet, indicatif compris. `tel-national` : sans indicatif. */
-type RemplissageDeTelephone = 'tel' | 'tel-national';
-/**
- * Numero de telephone. La valeur du modele ne garde que les chiffres et le `+` de
- * tete ; la saisie s'affiche telle qu'elle a ete tapee.
- *
- * ```html
- * <st-phone-field libelle="Telephone portable" [formField]="contact.telephone" />
- * <!-- schema : validate(chemin.telephone, ({ value }) => erreurTelephone(value())) -->
- * ```
+ * ⚠️ **`masque` : un IBAN connu ne s'expose pas par-dessus l'epaule.** Au repos, le champ montre
+ * `masquerIban` (« CH74 •••• •••• •••• •291 1 ») ; « Reveler 30s », bouton bascule a
+ * `aria-pressed` dans le cadre, le montre en clair pour `rythme.tenue.revelation`, puis il se
+ * remasque — aussi a la sortie du champ, a l'envoi du formulaire et avant l'impression. Modifiable,
+ * le champ montre la valeur en clair pendant la saisie et en erreur : on ne corrige pas des points.
+ * En lecture seule, il reste masque meme en erreur ; sur papier, il est toujours masque.
  *
- * ⚠️ **Aucun formatage automatique.** Le groupement des chiffres depend du pays,
- * et reformater pendant la frappe renvoie le curseur en fin de ligne. La saisie
- * reste celle de la personne, espaces et points compris.
+ * ⚠️ **`aria-pressed` dit ce qui est A L'ECRAN** : vrai des que la valeur est en clair, quelle
+ * qu'en soit la raison (revelation, saisie, erreur). Enfonce, le bouton masque : en saisie, il
+ * prend le focus, et la sortie du champ masque la valeur (on ne tape pas dans des points). Le
+ * fond enfonce et l'oeil barre, eux, disent la revelation A LA DEMANDE, pour sa duree. Le nom
+ * « Reveler 30s » est complete par une description : l'etiquette du champ et la duree en toutes
+ * lettres (« 30s » se lirait « thirties » en anglais).
  *
- * ⚠️ **Pas de selecteur de pays, pas de verification par pays.** Il faudrait une
- * table des plans de numerotation, lourde et souvent perimee : c'est au serveur
- * de dire si le numero existe (SEC-5). `erreurTelephone` ne verifie que la forme.
+ * Le glyphe `banque` en tete du cadre est DECORATIF : l'etiquette porte le sens. Chasse fixe a
+ * zero barre (O et 0 ne se confondent plus), ilot de gauche a droite en ecriture inverse.
  *
- * `type="tel"`, et jamais `type="number"` : un numero n'est pas une quantite, et le
- * champ numerique retire le zero de tete et le `+`.
+ * `autocapitalize="characters"` et correction orthographique coupee : un IBAN
+ * n'est pas un mot, et une correction automatique le fausserait.
  */
-declare class StPhoneField extends ControleDeSaisie {
-    readonly autocomplete: _angular_core.InputSignal<RemplissageDeTelephone>;
-    private readonly brut;
-    /**
-     * La saisie telle que tapee, tant qu'elle represente encore la valeur ; une
-     * valeur changee de l'exterieur — remise a zero, pre-remplissage — l'emporte.
-     */
-    protected readonly affichage: _angular_core.Signal<string>;
-    protected surSaisie(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StPhoneField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StPhoneField, "st-phone-field", never, { "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class StIbanField extends ControleDeSaisie {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  private readonly element;
+  protected readonly annonce: AnnonceLocale;
+  /** Masque au repos, revelable pour `rythme.tenue.revelation` (un IBAN deja connu). */
+  readonly masque: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly detection;
+  private readonly bouton;
+  protected readonly idDuBouton: string;
+  private readonly enSaisie;
+  private readonly brut;
+  protected readonly revele: import("@angular/core").WritableSignal<boolean>;
+  /** Masque demande par le bouton alors que la valeur etait en clair (erreur). */
+  private readonly masqueDemande;
+  /** Impression en cours : sur papier, la valeur est masquee quoi qu'il arrive. */
+  private readonly impression;
+  private minuterie;
+  /** L'exemple aide a TAPER : en lecture seule, il n'a rien a dire. */
+  protected readonly aideLue: import("@angular/core").Signal<string | null>;
+  /** « Reveler 30s » : la duree de la revelation dite dans le nom du bouton, qui ne change pas. */
+  protected readonly libelleDuBouton: import("@angular/core").Signal<string>;
+  /** Ce que le bouton revele, et pour combien de temps : « IBAN du compte : 30 secondes ». */
+  protected readonly descriptionDuBouton: import("@angular/core").Signal<string>;
+  /**
+   * Masquee : au repos ; en lecture seule, meme au focus et meme en erreur ; toujours a
+   * l'impression. Modifiable, jamais pendant la saisie ni en erreur — un IBAN refuse n'est pas un
+   * IBAN connu, et on ne corrige pas des points (planche 3b) —, sauf masque demande par le bouton.
+   */
+  protected readonly masquee: import("@angular/core").Signal<boolean>;
+  /** Valeur en clair dans un champ `masque` : l'etat que dit le bouton bascule. */
+  protected readonly enClair: import("@angular/core").Signal<boolean>;
+  /**
+   * Brut pendant la saisie ; groupe par quatre au repos ; masque si demande. Une valeur changee de
+   * l'exterieur pendant la saisie — remise a zero du formulaire — l'emporte sur le brut, qui ne
+   * la represente plus.
+   */
+  protected readonly affichage: import("@angular/core").Signal<string>;
+  constructor();
+  protected auFocus(): void;
+  protected surSaisie(evenement: Event): void;
+  protected aLaSortie(): void;
+  protected basculer(): void;
+  protected remasquer(): void;
+  /** Avant l'impression : masque, et rendu tout de suite (l'impression n'attend pas le rendu). */
+  protected avantImpression(): void;
+  protected apresImpression(): void;
+  /**
+   * Enfonce, le bouton masque. En saisie, la valeur ne se masque qu'a la sortie du champ (on ne
+   * tape pas dans des points) : le focus passe au bouton, ou le clic l'avait laisse au champ.
+   */
+  private masquerALaDemande;
+  private duree;
+  /** Le focus quitte le champ ET son bouton : la valeur revelee se remasque. */
+  protected aLaSortieDuChamp(evenement: FocusEvent): void;
+  private arreterLaMinuterie;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StIbanField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StIbanField, "st-iban-field", never, {
+    "masque": {
+      "alias": "masque";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
 }
-
 /**
- * Un choix d'une liste : `st-select`, `st-combobox`, `st-multiselect`.
- *
- * La `valeur` part dans le modele, le `libelle` s'affiche : un identifiant
- * technique ne s'affiche jamais, et un libelle traduit ne s'envoie jamais.
+ * `standard` : le controle pose sur la surface. `tonale` : le meme controle sur un fond teinte
+ * (`surfaceConteneurBas`), sous le meme filet lisible (EA-07) : une barre de filtres, le compte
+ * debiteur d'une coquille etroite (planches 10 et 6, D108).
  */
-interface OptionDeListe {
-    readonly valeur: string;
-    readonly libelle: string;
-    readonly desactivee?: boolean;
-    /** Regroupe les options consecutives sous un intitule (`optgroup`). */
-    readonly groupe?: string;
-}
-/** Sans accents ni casse : « eleve » trouve « Élève ». */
-declare function normaliserPourRecherche(texte: string): string;
-/** Options dont le libelle CONTIENT le texte cherche, sans accents ni casse. */
-declare function filtrerOptions(options: readonly OptionDeListe[], recherche: string): readonly OptionDeListe[];
-
-interface BlocDOptions {
-    readonly groupe: string | null;
-    readonly options: readonly OptionDeListe[];
+export type VarianteDeSelect = 'standard' | 'tonale';
+interface BlocDOptions$1 {
+  /** Identite stable du bloc : la valeur de sa premiere option. */
+  readonly cle: string;
+  readonly groupe: string | null;
+  readonly options: readonly OptionDeListe[];
 }
 /**
  * Liste deroulante, sur un `select` NATIF.
@@ -743,45 +2967,120 @@ interface BlocDOptions {
  * option paraitrait choisie alors que personne ne l'a fait. Le modele vaut
  * alors `''`, que `required` refuse.
  *
- * `readonly` n'existe pas sur un `select` : le champ annonce `aria-readonly` et
- * ignore le changement, plutot que d'etre desactive — un champ desactive sort de
- * l'ordre de tabulation, et sa valeur ne se lit plus.
- */
-declare class StSelect extends ControleDeSaisie {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    readonly options: _angular_core.InputSignal<readonly OptionDeListe[]>;
-    /** Texte de l'option vide. Par defaut : « Choisir… ». */
-    readonly texteVide: _angular_core.InputSignal<string | null>;
-    /** WCAG 1.3.5 : `country`, `sex`, `honorific-prefix`… */
-    readonly autocomplete: _angular_core.InputSignal<string | null>;
-    /** Options consecutives d'un meme groupe, dans l'ordre fourni. */
-    protected readonly blocs: _angular_core.Signal<readonly BlocDOptions[]>;
-    protected surChoix(evenement: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSelect, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSelect, "st-select", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "texteVide": { "alias": "texteVide"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+ * `readonly` n'existe pas sur un `select` : le champ annonce `aria-readonly`, et le
+ * selecteur ne s'ouvre plus (clic et touches annules) plutot que d'etre desactive — un
+ * champ desactive sort de l'ordre de tabulation, et sa valeur ne se lit plus. Sans chevron :
+ * une liste qui ne s'ouvre pas ne promet pas de s'ouvrir.
+ *
+ * ⚠️ **Une valeur absente des options n'est jamais tue** (A1131). Beneficiaire cloture,
+ * options rechargees : le modele garde un identifiant qu'aucune option ne porte, et le
+ * navigateur afficherait « Choisir… » pendant que le formulaire part avec la valeur
+ * invisible. Elle s'affiche « Valeur non affichable » (option desactivee, choisie), et un
+ * avertissement le dit en developpement — SANS la valeur, qui peut etre un compte ou un IBAN
+ * (une valeur sensible n'est jamais journalisee).
+ */
+export declare class StSelect extends ControleDeSaisie {
+  /**
+   * Un texte de donnees : sans commande de direction, et isole par son element (`dir="auto"` ou
+   * `<bdi>`), il ne reordonne ni lui-meme ni ce qui l'entoure (audit du 2026-09-26, S-1 ; audit
+   * etendu du 2026-09-27, A-2).
+   */
+  protected readonly affichable: typeof sansCommandesDeDirection;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  readonly options: import("@angular/core").InputSignal<readonly OptionDeListe[]>;
+  /** Texte de l'option vide. Par defaut : « Choisir… ». */
+  readonly texteVide: import("@angular/core").InputSignal<string | null>;
+  /** WCAG 1.3.5 : `country`, `sex`, `honorific-prefix`… */
+  readonly autocomplete: import("@angular/core").InputSignal<TypeDAutocompletion | null>;
+  /** Glyphe decoratif de tete, dans le cadre (l'etiquette porte le sens). */
+  readonly icone: import("@angular/core").InputSignal<"iban" | "code" | "devise" | "fichier" | "message" | "menu" | "accessibilite" | "appareils" | "arborescence" | "asterisque" | "badge-coche" | "banque" | "batiment" | "bifurcation" | "billets" | "billets-envoi" | "billets-pile" | "boite" | "boite-de-reception" | "bouclier" | "bouclier-alerte" | "bouclier-coche" | "bouclier-coeur" | "bouclier-croix" | "bouclier-moitie" | "bouclier-recherche" | "bouclier-utilisateur" | "boussole" | "bouton-curseur" | "bulle-question" | "cadenas" | "cadenas-horloge" | "cadenas-ouvert" | "cadre-pied" | "cadre-texte" | "calendrier" | "calendrier-evenement" | "calendrier-horloge" | "calendrier-jour" | "calques" | "carte-bancaire" | "carte-bancaire-barre" | "carte-bancaire-cadenas" | "carte-contact" | "carte-identite" | "cartes-empilees" | "case-cochee" | "casse" | "cercle" | "cercle-alerte" | "cercle-chevron-bas" | "cercle-coche" | "cercle-coche-ouvert" | "cercle-croix" | "cercle-info" | "cercle-moins" | "cercle-plus" | "cercle-question" | "certificat" | "chandelier" | "chargement" | "cheque" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "chevrons-droite" | "chevrons-haut-bas" | "cle" | "cloche" | "cloche-sonnerie" | "coche" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier-image" | "fichier-pdf" | "fichier-texte" | "filtre" | "filtre-barre" | "filtre-lignes" | "fleche-bas" | "fleche-bas-gauche" | "fleche-bas-ligne" | "fleche-droite" | "fleche-gauche" | "fleche-haut" | "fleche-haut-droite" | "fleche-haut-ligne" | "fleche-large-haut" | "fleches-gauche-droite" | "flocon" | "flou" | "formes" | "globe" | "graphique-anneau" | "graphique-barres" | "graphique-barres-cadre" | "graphique-camembert" | "graphique-ligne" | "graphique-lignes" | "grille" | "grille-lignes" | "hexagone" | "historique" | "horloge" | "horloge-fleche" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu-ouvert" | "minuteur" | "mise-au-point" | "mise-en-page-image" | "moins" | "nuage-barre" | "nuage-televerser" | "octogone-alerte" | "oeil" | "oeil-barre" | "panneau-gauche" | "parametres" | "parapluie" | "parchemin" | "pieces" | "plus" | "pointeur" | "points" | "points-verticaux" | "portefeuille" | "portefeuille-cartes" | "presse-papiers-coche" | "presse-papiers-horloge" | "priorite-haute" | "rafraichir" | "recherche" | "recherche-barre" | "recherche-texte" | "rectangle-points" | "recu" | "redemarrer" | "reglages" | "regle" | "reseau-jauge" | "rotation-arriere" | "routeur" | "sablier" | "sablier-bas" | "sablier-haut" | "sac-argent" | "sans-contact" | "serveur" | "soleil" | "style-de-trait" | "synchro" | "synchro-probleme" | "tableau" | "tableau-de-bord" | "tableau-de-bord-plus" | "tablette" | "tabulation" | "telecharger" | "telephone-mobile" | "televerser" | "tendance-baisse" | "tendance-hausse" | "terminal" | "tirelire" | "triangle-alerte" | "triangle-bas" | "triangle-haut" | "trombone" | "utilisateur" | "utilisateur-crayon" | "utilisateurs" | "wifi" | "wifi-barre" | null>;
+  /** Le style de l'etiquette (voir `st-form-field`). */
+  readonly presentation: import("@angular/core").InputSignal<PresentationDeLibelle>;
+  /**
+   * `tonale` pose le controle sur un fond teinte, memes etats et meme filet (D108). La lecture
+   * seule et la desactivation gardent leur fond propre : elles se lisent d'abord.
+   */
+  readonly variante: import("@angular/core").InputSignal<VarianteDeSelect>;
+  /** Options consecutives d'un meme groupe, dans l'ordre fourni. */
+  protected readonly blocs: import("@angular/core").Signal<readonly BlocDOptions$1[]>;
+  /** La valeur du modele, quand aucune option ne la porte (sinon `null`). */
+  protected readonly valeurInconnue: import("@angular/core").Signal<string | null>;
+  constructor();
+  /** Lecture seule : le selecteur ne s'ouvre pas au clic (le focus, lui, se prend). */
+  protected surPression(evenement: MouseEvent): void;
+  /** Lecture seule : ni Espace, ni Entree, ni fleches, ni lettres ne changent la valeur. */
+  protected surTouche(evenement: KeyboardEvent): void;
+  protected surChoix(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSelect, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSelect, "st-select", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "texteVide": {
+      "alias": "texteVide";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "presentation": {
+      "alias": "presentation";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
 }
-
+/**
+ * Disque plein d'un jour : borne de debut ou de fin d'une plage (capsule d'un cote), ou date
+ * seule (jour choisi, plage d'un jour, borne sans son autre).
+ */
+type Borne = 'debut' | 'fin' | 'seule';
 interface Jour {
-    readonly date: DateIso;
-    /** Jour d'un mois voisin : cellule vide, la date vit dans son propre mois. */
-    readonly horsDuMois: boolean;
-    readonly numero: string;
-    readonly nom: string;
-    readonly horsBornes: boolean;
-    readonly choisi: boolean;
-    readonly dansLaPlage: boolean;
-    readonly aujourdHui: boolean;
+  readonly date: DateIso;
+  /** Jour d'un mois voisin : cellule vide, la date vit dans son propre mois. */
+  readonly horsDuMois: boolean;
+  readonly numero: string;
+  readonly nom: string;
+  readonly horsBornes: boolean;
+  readonly borne: Borne | null;
+  readonly dansLaPlage: boolean;
+  readonly aujourdHui: boolean;
+  readonly rejete: boolean;
+}
+/** Annees offertes par le saut d'annee, bornes comprises. */
+export interface AnneesDuCalendrier {
+  readonly min: number;
+  readonly max: number;
 }
 /**
- * Calendrier d'un mois, pour choisir une date.
+ * Calendrier d'un mois, pour choisir une date ou montrer une periode.
  *
  * ```html
  * <st-calendar [selection]="depart()" dateMin="2026-09-17" (choix)="depart.set($event)" />
+ * <st-calendar pleineLargeur [plage]="periode()" [annees]="{ min: 1900, max: 2026 }">
+ *   <span stPied>Periode : 8 jours</span>
+ * </st-calendar>
  * ```
  *
  * ⚠️ **Une aide, jamais la seule voie.** Dans `st-date-field`, le calendrier
  * complete un champ texte : une date de naissance se tape plus vite qu'elle ne se
- * cherche mois par mois, et un calendrier reste penible au lecteur d'ecran.
+ * cherche mois par mois, et un calendrier reste penible au lecteur d'ecran. Le saut
+ * d'annee (liste native) evite les quarante Maj + Page d'une date de naissance.
  *
  * ⚠️ **Le clavier navigue de DATE en date, pas de cellule en cellule** (decision
  * D7 de l'audit de la vague 3). Fleche droite le 30 septembre mene au 1er
@@ -790,71 +3089,179 @@ interface Jour {
  * entre cellules affichees : il aurait fallu la contourner sur chaque touche qui
  * compte, et elle aurait fait entrer le CDK dans les formulaires.
  *
- * Semaine commencant au jour de la locale, noms de jours et de mois dans la
- * langue courante, « aujourd'hui » dans le fuseau de la personne
- * (`FUSEAU_PAR_DEFAUT`) et non celui du poste.
- */
-declare class StCalendar {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    private readonly locale;
-    private readonly element;
-    private readonly injecteur;
-    private readonly aujourdHui;
-    readonly selection: _angular_core.InputSignal<string | null>;
-    readonly dateMin: _angular_core.InputSignal<string | null>;
-    readonly dateMax: _angular_core.InputSignal<string | null>;
-    /** Periode a faire ressortir, pour un choix de plage. */
-    readonly plage: _angular_core.InputSignal<PlageDeDates | null>;
-    readonly choix: _angular_core.OutputEmitterRef<string>;
-    /** Echap : le conteneur decide de fermer, et ou rendre le focus. */
-    readonly fermeture: _angular_core.OutputEmitterRef<void>;
-    protected readonly identifiants: {
-        readonly titre: `${string}-titre`;
-        readonly aide: `${string}-aide`;
-    };
-    /** La date qui porte le focus. Suit la selection, bornee. */
-    private readonly active;
-    private readonly premierJour;
-    protected readonly titre: _angular_core.Signal<string>;
-    protected readonly joursDeLaSemaine: _angular_core.Signal<{
-        court: string;
-        long: string;
-    }[]>;
-    protected readonly semaines: _angular_core.Signal<readonly (readonly Jour[])[]>;
-    protected readonly moisPrecedentPossible: _angular_core.Signal<boolean>;
-    protected readonly moisSuivantPossible: _angular_core.Signal<boolean>;
-    protected estActive(date: DateIso): boolean;
-    /** Amene le focus sur la date active. */
-    focus(): void;
-    protected changerDeMois(ecart: number): void;
-    protected choisir(jour: Jour): void;
-    protected surTouche(evenement: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StCalendar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCalendar, "st-calendar", never, { "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "dateMin": { "alias": "dateMin"; "required": false; "isSignal": true; }; "dateMax": { "alias": "dateMax"; "required": false; "isSignal": true; }; "plage": { "alias": "plage"; "required": false; "isSignal": true; }; }, { "choix": "choix"; "fermeture": "fermeture"; }, never, never, true, never>;
+ * ⚠️ **Echap n'appartient au calendrier que s'il est `fermable`** (pose par
+ * `st-date-field` et `st-date-range`) : il la consomme alors, et l'arrete — sans quoi le
+ * `st-dialog` qui contient le formulaire se fermerait avec lui. Seul, il la laisse passer.
+ *
+ * ⚠️ **Un clic ne deplace pas le focus** (`mousedown` annule partout, sauf sur la liste
+ * d'annees) : sous WebKit, un bouton clique ne prend pas le focus mais retire celui de l'element
+ * actif, et un clic dans le blanc le donnait a l'ancetre focalisable (`cdk-dialog-container`) ;
+ * le conteneur qui ferme a la sortie du focus retirait le calendrier avant le clic. Quand le
+ * focus est dans la grille, un changement de mois ou un choix au clic le pose sur la nouvelle
+ * date active : le bouton du jour qui le portait disparait avec son mois.
+ *
+ * Reference Claude Design (planches 3a et 3b) : bornes et jour choisi en disques pleins de
+ * 40 px, capsule de plage coupee carrement au changement de ligne, aujourd'hui marque d'un point.
+ * Semaine commencant au jour de la locale, noms de jours et de mois dans la langue courante,
+ * « aujourd'hui » dans le fuseau de la personne (`FUSEAU_PAR_DEFAUT`) et non celui du poste,
+ * relu a chaque prise de focus (un calendrier ouvert la veille ne garde pas la veille).
+ */
+export declare class StCalendar {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  private readonly fuseau;
+  private readonly element;
+  private readonly injecteur;
+  private readonly aujourdHui;
+  readonly selection: import("@angular/core").InputSignal<string | null>;
+  readonly dateMin: import("@angular/core").InputSignal<string | null>;
+  readonly dateMax: import("@angular/core").InputSignal<string | null>;
+  /** Periode a faire ressortir, pour un choix de plage. */
+  readonly plage: import("@angular/core").InputSignal<PlageDeDates | null>;
+  /**
+   * Date refusee par une regle de l'application (validation differee) : tuile rouge barree. La
+   * raison se dit dans le pied (`[stPied]`), en texte.
+   */
+  readonly rejet: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Annees du saut d'annee. Par defaut : celles des bornes, sinon dix ans de part et d'autre
+   * de l'annee courante. Une date de naissance passe `{ min: 1900, max: <annee courante> }`.
+   */
+  readonly annees: import("@angular/core").InputSignal<AnneesDuCalendrier | null>;
+  /** Occupe la largeur de son conteneur (cases fluides, 44 px de haut) : calendrier deploye. */
+  readonly pleineLargeur: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Un conteneur ecoute `fermeture` : Echap lui appartient, et l'aide le dit. */
+  readonly fermable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly choix: import("@angular/core").OutputEmitterRef<string>;
+  /** Echap (calendrier `fermable`) : le conteneur decide de fermer, et ou rendre le focus. */
+  readonly fermeture: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly identifiants: {
+    readonly titre: `${string}-titre`;
+    readonly aide: `${string}-aide`;
+    readonly pied: `${string}-pied`;
+  };
+  /** La date qui porte le focus. Suit la selection, bornee. */
+  private readonly active;
+  private readonly premierJour;
+  protected readonly anneeActive: import("@angular/core").Signal<number>;
+  protected readonly titre: import("@angular/core").Signal<string>;
+  protected readonly listeDAnnees: import("@angular/core").Signal<readonly number[]>;
+  /** « Lun », « Mar » : l'abreviation de la langue, sans son point, a l'initiale. */
+  protected readonly joursDeLaSemaine: import("@angular/core").Signal<{
+    court: string;
+    long: string;
+  }[]>;
+  protected readonly semaines: import("@angular/core").Signal<readonly (readonly Jour[])[]>;
+  protected readonly moisPrecedentPossible: import("@angular/core").Signal<boolean>;
+  protected readonly moisSuivantPossible: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected estActive(date: DateIso): boolean;
+  /** Amene le focus sur la date active. */
+  focus(): void;
+  protected relireAujourdHui(): void;
+  protected changerDeMois(ecart: number): void;
+  protected changerDAnnee(evenement: Event): void;
+  protected choisir(jour: Jour): void;
+  /** Un clic ne deplace pas le focus, sauf sur la liste d'annees (liste native a ouvrir). */
+  protected surAppui(evenement: MouseEvent): void;
+  private focusDansLaGrille;
+  private focusApresRendu;
+  protected surTouche(evenement: KeyboardEvent): void;
+  /**
+   * Le sens d'ecriture HERITE, sans style calcule (ni global `getComputedStyle`, ni mise en
+   * page) : `:dir()` quand le moteur le connait, sinon l'attribut `dir` le plus proche.
+   */
+  private ecritDeDroiteAGauche;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCalendar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StCalendar, "st-calendar", never, {
+    "selection": {
+      "alias": "selection";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMin": {
+      "alias": "dateMin";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMax": {
+      "alias": "dateMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "plage": {
+      "alias": "plage";
+      "required": false;
+      "isSignal": true;
+    };
+    "rejet": {
+      "alias": "rejet";
+      "required": false;
+      "isSignal": true;
+    };
+    "annees": {
+      "alias": "annees";
+      "required": false;
+      "isSignal": true;
+    };
+    "pleineLargeur": {
+      "alias": "pleineLargeur";
+      "required": false;
+      "isSignal": true;
+    };
+    "fermable": {
+      "alias": "fermable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "choix": "choix";
+    "fermeture": "fermeture";
+  }, never, ["[stPied]"], true, never>;
 }
-
 /**
  * Cle d'un fichier choisi : deux choix du meme fichier ne l'ajoutent pas deux
  * fois, et l'application s'en sert pour dire ou en est chaque televersement.
  */
-declare function cleDeFichier(fichier: File): string;
+export declare function cleDeFichier(fichier: File): string;
 /**
  * Ou en est un fichier, vu de l'application. `message` dit POURQUOI un fichier
  * est refuse — « antivirus indisponible » et « type refuse » n'appellent pas la
  * meme suite (UX-3 de la 0.6.0).
  */
-interface EtatDeTeleversementAffiche {
-    readonly etape: 'en-cours' | 'depose' | 'refuse';
-    /** 0 a 100, pendant l'envoi. */
-    readonly progression?: number;
-    readonly message?: string;
+export interface EtatDeTeleversementAffiche {
+  readonly etape: 'en-cours' | 'depose' | 'refuse';
+  /** 0 a 100, pendant l'envoi. */
+  readonly progression?: number;
+  /** Ce que dit la ligne sous le nom : « Chiffrement en cours... », la raison d'un refus. */
+  readonly message?: string;
+  /**
+   * Texte court en fin de ligne : debit, duree, verdict (« 68 % (1,4 Mo/s) »). Par defaut, le
+   * pourcentage pendant l'envoi, et rien ensuite.
+   */
+  readonly detail?: string;
+  /**
+   * Pendant l'envoi : `false` quand il ne peut plus etre interrompu (confirmation du depot en
+   * cours). Le bouton « Annuler » n'est alors pas rendu. Vrai par defaut.
+   */
+  readonly annulable?: boolean;
+}
+/** Un morceau d'une phrase affichee : du texte, ou un nom de fichier a isoler. */
+interface MorceauDePhrase {
+  readonly texte: string;
+  readonly nom: boolean;
+}
+/** Des fichiers ecartes par `nombreMax` : leur phrase (annonce, presence), et ses morceaux. */
+interface RefusDuNombre {
+  readonly texte: string;
+  readonly morceaux: readonly MorceauDePhrase[];
 }
 /**
  * Choix de fichiers, sur un `input type="file"` natif.
  *
  * ```html
  * <st-file-upload libelle="Justificatifs" accept=".pdf, image/*" [tailleMax]="5_000_000" multiple
- *   [formField]="dossier.pieces" />
+ *   [nombreMax]="3" [formField]="dossier.pieces" />
  * <!-- schema : validate(chemin.pieces, ({ value }) => erreursDeFichiers(value(), regles)) -->
  * ```
  *
@@ -863,62 +3270,537 @@ interface EtatDeTeleversementAffiche {
  *
  * ⚠️ **L'element natif reste la voie principale** (FE-4) : il ouvre le selecteur
  * du systeme, l'appareil photo sur mobile, et se commande au clavier. Il est
- * masque visuellement, pas retire : le bouton affiche est son etiquette. Le
- * depot par glisser est un complement a la souris, jamais la seule voie.
+ * masque visuellement, pas retire : le bouton affiche est son substitut a la souris,
+ * et montre son focus. Le depot par glisser est un complement, jamais la seule voie
+ * (WCAG 2.5.7).
  *
  * ⚠️ **Aucun apercu d'image** (SEC-7). Un apercu passe par une adresse `blob:`
  * que la politique de securite du contenu doit autoriser, et un SVG affiche peut
  * porter du script. Le nom et la taille suffisent a reconnaitre un fichier.
  *
- * ⚠️ **`accept`, `tailleMax` et `nombreMax` sont un confort** (SEC-5) : ils
- * s'affichent en aide et filtrent le selecteur du systeme, mais la verification
- * est dans le schema — `erreursDeFichiers` —, et le serveur relit le contenu.
+ * ⚠️ **Les noms s'affichent sans commandes de direction** (`nomAffichable`) : un
+ * `facture\u202efdp.exe` ne se presente pas en PDF, ni a l'ecran, ni dans les etiquettes, ni
+ * dans les annonces. Cite dans une phrase du dictionnaire (un statut, des fichiers ecartes), le
+ * nom est en plus isole dans son ilot de gauche a droite : la phrase ne se reordonne pas autour
+ * d'un nom en hebreu ou en arabe (audit UI du 2026-09-27, D-4).
  *
- * Chaque changement de la liste s'annonce : « 2 fichiers choisis ». Un fichier
- * retire rend le focus au bouton de retrait suivant, ou au choix de fichiers : le
- * focus ne tombe jamais sur le document.
+ * ⚠️ **`accept`, `tailleMax` et `nombreMax` sont un confort** (SEC-5) : ils
+ * s'affichent en consignes et filtrent le choix, mais la verification est dans le schema —
+ * `erreursDeFichiers` —, et le serveur relit le contenu.
+ *
+ * ⚠️ **`readonly` ne desactive pas** : le champ natif reste dans la tabulation (sa liste se
+ * parcourt et se lit) et n'ouvre ni selecteur ni depot ; les retraits sont indisponibles
+ * (`aria-disabled`), pas retires. Chromium expose `input type="file"` en role `button`, qui ne
+ * prend pas `aria-readonly` en charge : le champ natif porte donc `aria-disabled` (focalisable,
+ * annonce indisponible), et le substitut dit « Lecture seule », lu en description.
+ *
+ * Chaque changement s'annonce : « 2 fichiers choisis. », « X depose. », « X refuse : raison. ».
+ * Des fichiers qui changent d'etat ensemble se disent en UNE annonce (D-15). Les fichiers ecartes
+ * par `nombreMax` sont NOMMES en texte visible, en liste de la langue, relie au champ natif, et
+ * l'annonce reprend ce texte. Un fichier retire rend le focus au bouton de retrait suivant, ou au
+ * choix de fichiers ; un fichier remplace, au bouton de sa nouvelle ligne : le focus ne tombe
+ * jamais sur le document.
  *
  * ⚠️ **Il ne televerse pas.** `etats` dit ou en est chaque fichier, et le bouton
- * de la ligne devient « Annuler » pendant l'envoi : le trajet — declaration, depot
+ * de la ligne devient « Annuler » pendant l'envoi (le MEME bouton : il garde le focus a
+ * l'arrivee ; absent quand l'envoi n'est plus annulable, le focus passant alors au choix de
+ * fichiers) : le trajet — declaration, depot
  * pre-signe, confirmation antivirus — vit dans `StTeleversement`
  * (`@starterlib/core`), seul a parler au reseau.
  */
-declare class StFileUpload extends ContratDeChamp implements FormValueControl<readonly File[]> {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    private readonly locale;
-    private readonly element;
-    private readonly injecteur;
-    readonly value: _angular_core.ModelSignal<readonly File[]>;
-    /** Attribut `accept` natif : `.pdf, image/*`. */
-    readonly accept: _angular_core.InputSignal<string>;
-    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** En octets. Affiche en aide ; la verification est dans le schema. */
-    readonly tailleMax: _angular_core.InputSignal<number | null>;
-    /**
-     * Ou en est chaque fichier, par `cleDeFichier`. Le composant AFFICHE ce trajet,
-     * il ne le fait pas : `StTeleversement` de `@starterlib/core` s'en charge.
-     */
-    readonly etats: _angular_core.InputSignal<ReadonlyMap<string, EtatDeTeleversementAffiche> | null>;
-    protected readonly annonce: AnnonceLocale;
-    protected readonly survol: _angular_core.WritableSignal<boolean>;
-    protected readonly aideLue: _angular_core.Signal<string | null>;
-    protected readonly lignes: _angular_core.Signal<{
-        fichier: File;
-        cle: string;
-        taille: string;
-        etat: EtatDeTeleversementAffiche | null;
-    }[]>;
-    protected surChoix(evenement: Event): void;
-    protected surSurvol(evenement: DragEvent): void;
-    protected surDepot(evenement: DragEvent): void;
-    /** Emis quand la personne interrompt un envoi : c'est l'application qui annule. */
-    readonly annulation: _angular_core.OutputEmitterRef<File>;
-    protected retirer(indice: number): void;
-    protected aLaSortie(evenement: FocusEvent): void;
-    private ajouter;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StFileUpload, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StFileUpload, "st-file-upload", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "tailleMax": { "alias": "tailleMax"; "required": false; "isSignal": true; }; "etats": { "alias": "etats"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "annulation": "annulation"; }, never, never, true, never>;
+export declare class StFileUpload extends ContratDeChamp implements FormValueControl<readonly File[]> {
+  protected readonly libelles: import("@angular/core").Signal<LibellesUi>;
+  private readonly locale;
+  private readonly element;
+  private readonly document;
+  private readonly injecteur;
+  private readonly natif;
+  readonly value: import("@angular/core").ModelSignal<readonly File[]>;
+  /** Attribut `accept` natif : `.pdf, image/*`. Dit en clair dans les consignes. */
+  readonly accept: import("@angular/core").InputSignal<string>;
+  readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** En octets. Dit dans les consignes ; la verification est dans le schema. */
+  readonly tailleMax: import("@angular/core").InputSignal<number | null>;
+  /**
+   * Nombre de fichiers au plus, en choix multiple : dit dans les consignes, et un choix qui le
+   * depasse n'ajoute que ce qui tient ; les fichiers ecartes sont nommes en texte visible.
+   */
+  readonly nombreMax: import("@angular/core").InputSignal<number | null>;
+  /** Texte du bouton de choix. `null` : « Choisir un fichier » ou « Choisir des fichiers ». */
+  readonly libelleDuChoix: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Ou en est chaque fichier, par `cleDeFichier`. Le composant AFFICHE ce trajet,
+   * il ne le fait pas : `StTeleversement` de `@starterlib/core` s'en charge.
+   */
+  readonly etats: import("@angular/core").InputSignal<ReadonlyMap<string, EtatDeTeleversementAffiche> | null>;
+  /** Emis quand la personne interrompt un envoi : c'est l'application qui annule. */
+  readonly annulation: import("@angular/core").OutputEmitterRef<File>;
+  /**
+   * Emis avec le fichier REMPLACE (« Remplacer » d'une ligne refusee), une fois le nouveau
+   * choisi : l'application oublie son etat, le nouveau fichier est deja dans le modele.
+   */
+  readonly remplacement: import("@angular/core").OutputEmitterRef<File>;
+  protected readonly annonce: AnnonceLocale;
+  protected readonly survol: import("@angular/core").WritableSignal<boolean>;
+  private readonly identifiants;
+  protected readonly identifiantDesConsignes: string;
+  protected readonly identifiantDeLaLecture: string;
+  protected readonly identifiantDuRefus: string;
+  /** « c.pdf non ajoute : 2 fichiers au plus. », jusqu'au prochain choix ou retrait. */
+  protected readonly refusDuNombre: import("@angular/core").WritableSignal<RefusDuNombre | null>;
+  /** `dragenter` et `dragleave` se repondent a chaque enfant survole : on les compte. */
+  private entreesDuGlisser;
+  /** L'indice de la ligne a remplacer, le temps que le selecteur du systeme reponde. */
+  private aRemplacer;
+  /** Choix et depot ouverts : ni desactive, ni en lecture seule. */
+  protected readonly ouvert: import("@angular/core").Signal<boolean>;
+  protected readonly texteDuChoix: import("@angular/core").Signal<string>;
+  /** Aide, types acceptes, taille et nombre au plus, raisons de desactivation. */
+  protected readonly consignes: import("@angular/core").Signal<string | null>;
+  protected readonly descriptionsDesConsignes: import("@angular/core").Signal<string[]>;
+  protected readonly lignes: import("@angular/core").Signal<{
+    fichier: File;
+    cle: string;
+    nom: string;
+    etape: "en-cours" | "depose" | "refuse" | null;
+    icone: "iban" | "code" | "devise" | "fichier" | "message" | "menu" | "accessibilite" | "appareils" | "arborescence" | "asterisque" | "badge-coche" | "banque" | "batiment" | "bifurcation" | "billets" | "billets-envoi" | "billets-pile" | "boite" | "boite-de-reception" | "bouclier" | "bouclier-alerte" | "bouclier-coche" | "bouclier-coeur" | "bouclier-croix" | "bouclier-moitie" | "bouclier-recherche" | "bouclier-utilisateur" | "boussole" | "bouton-curseur" | "bulle-question" | "cadenas" | "cadenas-horloge" | "cadenas-ouvert" | "cadre-pied" | "cadre-texte" | "calendrier" | "calendrier-evenement" | "calendrier-horloge" | "calendrier-jour" | "calques" | "carte-bancaire" | "carte-bancaire-barre" | "carte-bancaire-cadenas" | "carte-contact" | "carte-identite" | "cartes-empilees" | "case-cochee" | "casse" | "cercle" | "cercle-alerte" | "cercle-chevron-bas" | "cercle-coche" | "cercle-coche-ouvert" | "cercle-croix" | "cercle-info" | "cercle-moins" | "cercle-plus" | "cercle-question" | "certificat" | "chandelier" | "chargement" | "cheque" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "chevrons-droite" | "chevrons-haut-bas" | "cle" | "cloche" | "cloche-sonnerie" | "coche" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier-image" | "fichier-pdf" | "fichier-texte" | "filtre" | "filtre-barre" | "filtre-lignes" | "fleche-bas" | "fleche-bas-gauche" | "fleche-bas-ligne" | "fleche-droite" | "fleche-gauche" | "fleche-haut" | "fleche-haut-droite" | "fleche-haut-ligne" | "fleche-large-haut" | "fleches-gauche-droite" | "flocon" | "flou" | "formes" | "globe" | "graphique-anneau" | "graphique-barres" | "graphique-barres-cadre" | "graphique-camembert" | "graphique-ligne" | "graphique-lignes" | "grille" | "grille-lignes" | "hexagone" | "historique" | "horloge" | "horloge-fleche" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu-ouvert" | "minuteur" | "mise-au-point" | "mise-en-page-image" | "moins" | "nuage-barre" | "nuage-televerser" | "octogone-alerte" | "oeil" | "oeil-barre" | "panneau-gauche" | "parametres" | "parapluie" | "parchemin" | "pieces" | "plus" | "pointeur" | "points" | "points-verticaux" | "portefeuille" | "portefeuille-cartes" | "presse-papiers-coche" | "presse-papiers-horloge" | "priorite-haute" | "rafraichir" | "recherche" | "recherche-barre" | "recherche-texte" | "rectangle-points" | "recu" | "redemarrer" | "reglages" | "regle" | "reseau-jauge" | "rotation-arriere" | "routeur" | "sablier" | "sablier-bas" | "sablier-haut" | "sac-argent" | "sans-contact" | "serveur" | "soleil" | "style-de-trait" | "synchro" | "synchro-probleme" | "tableau" | "tableau-de-bord" | "tableau-de-bord-plus" | "tablette" | "tabulation" | "telecharger" | "telephone-mobile" | "televerser" | "tendance-baisse" | "tendance-hausse" | "terminal" | "tirelire" | "triangle-alerte" | "triangle-bas" | "triangle-haut" | "trombone" | "utilisateur" | "utilisateur-crayon" | "utilisateurs" | "wifi" | "wifi-barre";
+    statut: string | null;
+    morceauxDuStatut: readonly MorceauDePhrase[] | null;
+    detail: string | null;
+    progression: number | null;
+    taille: string;
+    annulable: boolean;
+  }[]>;
+  constructor();
+  /** Le substitut, a la souris : il ouvre le selecteur du champ natif. */
+  protected ouvrir(): void;
+  /** En lecture seule, le champ natif garde le focus mais n'ouvre pas le selecteur. */
+  protected surClicDuNatif(evenement: MouseEvent): void;
+  protected surChoix(evenement: Event): void;
+  /** Le selecteur ferme sans choix : un « Remplacer » en attente est oublie. */
+  protected surAbandon(): void;
+  protected surEntreeDuGlisser(evenement: DragEvent): void;
+  /**
+   * ⚠️ `preventDefault` sur CHAQUE `dragover`, sans quoi le navigateur ne delivre pas `drop`
+   * (et ouvre le fichier a la place de la page). Fermee, la zone le dit par `dropEffect`.
+   */
+  protected surSurvol(evenement: DragEvent): void;
+  protected surSortieDuGlisser(): void;
+  protected surDepot(evenement: DragEvent): void;
+  /** « Remplacer » d'une ligne : le prochain choix prend sa place. */
+  protected remplacer(indice: number): void;
+  /** Le bouton de la ligne : annuler pendant l'envoi, retirer sinon. */
+  protected agirSurLaLigne(fichier: File, etape: EtatDeTeleversementAffiche['etape'] | null, annulable: boolean, indice: number): void;
+  protected retirer(indice: number): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  /**
+   * UNE annonce pour tous les fichiers qui changent d'etat ensemble : `annoncer` remplace le texte
+   * encore en attente, et une annonce par fichier ne laissait dire que le dernier (audit UI du
+   * 2026-09-27, D-15). Les fichiers deposes en une phrase, leurs noms en liste de la langue, puis
+   * chaque refus avec sa raison.
+   */
+  private annonceDesEtapes;
+  /** Le refus d'un fichier, et sa raison quand elle n'est pas la phrase du dictionnaire. */
+  private phraseDuRefus;
+  /** Les fichiers ecartes par `nombreMax`, nommes ; chaque nom isole a l'affichage (D-4). */
+  private refusDuNombreMax;
+  private remplacerA;
+  private ajouter;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StFileUpload, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StFileUpload, "st-file-upload", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "accept": {
+      "alias": "accept";
+      "required": false;
+      "isSignal": true;
+    };
+    "multiple": {
+      "alias": "multiple";
+      "required": false;
+      "isSignal": true;
+    };
+    "tailleMax": {
+      "alias": "tailleMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "nombreMax": {
+      "alias": "nombreMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDuChoix": {
+      "alias": "libelleDuChoix";
+      "required": false;
+      "isSignal": true;
+    };
+    "etats": {
+      "alias": "etats";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+    "annulation": "annulation";
+    "remplacement": "remplacement";
+  }, never, never, true, never>;
+}
+/**
+ * Plusieurs valeurs LIBRES (courriels a notifier, references, mots-cles), en etiquettes
+ * retirables : ni `st-multiselect` (options fermees) ni `st-input` ne le permettent (lot 252,
+ * ADR 0005 D78, D79, D81).
+ *
+ * ```html
+ * <st-tag-input
+ *   libelle="Adresses a notifier"
+ *   [valider]="adresseValide"
+ *   [nombreMax]="5"
+ *   [formField]="notification.adresses"
+ * />
+ * ```
+ *
+ * - Entree ajoute le texte tape, sans soumettre le formulaire englobant ; chaque separateur
+ *   aussi (`,` et `;` par defaut), sans s'ecrire. Rien pendant une composition IME : l'Entree
+ *   qui la clot valide la composition, pas la valeur.
+ * - Un collage qui contient des separateurs (ou des fins de ligne) ajoute chaque valeur.
+ * - ⚠️ **Le texte en attente reste dans le champ** : jamais ajoute implicitement, ni a la sortie
+ *   du champ ni a l'envoi du formulaire. Une valeur ajoutee sans geste serait une valeur que la
+ *   personne n'a pas choisie.
+ * - Un doublon, une valeur que `valider` ecarte et une valeur au-dela de `nombreMax` n'entrent
+ *   pas : le texte reste a corriger, un message local le dit en texte visible, relie au champ,
+ *   et l'annonce le reprend.
+ * - Les valeurs sont un `st-tag-group` nomme par le libelle du champ ; chaque retrait est nomme
+ *   par `retirerLEtiquette` (« Retirer x »), rend le focus a la valeur suivante, sinon a la
+ *   precedente, sinon au champ. Une seule region d'annonce, celle du champ : ajouts, retraits et
+ *   refus y passent.
+ * - `readonly` : le champ reste focalisable, rien n'entre, et les croix sont masquees ;
+ *   `disabled` : hors de la tabulation, sur fond blanc (D66).
+ * - Le cadre a une hauteur MINIMALE : les etiquettes passent a la ligne, jamais tronquees.
+ */
+export declare class StTagInput extends ContratDeChamp implements FormValueControl<readonly string[]> {
+  private readonly libelles;
+  private readonly element;
+  readonly value: import("@angular/core").ModelSignal<readonly string[]>;
+  /** Ce qui ajoute le texte tape, en plus d'Entree. */
+  readonly separateurs: import("@angular/core").InputSignal<readonly string[]>;
+  /** Refus local d'un texte (une adresse mal formee) ; la validation du schema reste l'arbitre. */
+  readonly valider: import("@angular/core").InputSignal<((texte: string) => boolean) | null>;
+  /** Nombre de valeurs au plus (D78 : `max` est une borne de valeur du contrat Signal Forms). */
+  readonly nombreMax: import("@angular/core").InputSignal<number | null>;
+  protected readonly annonce: AnnonceLocale;
+  protected readonly identifiantDuRefus: string;
+  /** Le dernier refus, jusqu'a la prochaine frappe, au prochain ajout ou au prochain retrait. */
+  protected readonly refus: import("@angular/core").WritableSignal<string | null>;
+  protected readonly modifiable: import("@angular/core").Signal<boolean>;
+  protected readonly elements: import("@angular/core").Signal<readonly EtiquetteDeGroupe[]>;
+  protected readonly descriptionsDuRefus: import("@angular/core").Signal<string[]>;
+  constructor();
+  /** Entree et les separateurs ajoutent le texte tape. */
+  protected auClavier(evenement: KeyboardEvent): void;
+  /**
+   * Un separateur arrive aussi sans touche lisible (clavier virtuel, dictee) : le texte se coupe
+   * a chaque separateur, le dernier morceau reste en attente.
+   */
+  protected surSaisie(evenement: Event): void;
+  /** Un collage qui contient des separateurs ou des fins de ligne : chaque valeur est ajoutee. */
+  protected surCollage(evenement: ClipboardEvent): void;
+  protected retirer(valeur: string): void;
+  protected aLaSortie(evenement: FocusEvent): void;
+  /**
+   * Ajoute chaque texte qui peut l'etre, dans l'ordre, et rend ce qui reste a corriger dans le
+   * champ. Un refus se dit en texte visible et dans l'annonce, avec les ajouts.
+   */
+  private ajouter;
+  /** Doublon d'abord, puis la limite, puis `valider` : le blocage le plus utile a lever. */
+  private motifDuRefus;
+  /** Ce qui separe deux textes refuses laisses dans le champ : le premier separateur, puis une espace. */
+  private jointure;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StTagInput, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StTagInput, "st-tag-input", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "separateurs": {
+      "alias": "separateurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "valider": {
+      "alias": "valider";
+      "required": false;
+      "isSignal": true;
+    };
+    "nombreMax": {
+      "alias": "nombreMax";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
+}
+/**
+ * Ce que `st-address-fieldset` offre a une recherche inseree en son sein (`st-address-search`, de
+ * `@starterlib/ui/selection`) : le champ ne connait pas la recherche, la recherche l'injecte.
+ * `ui/saisie` n'importe que le tronc : c'est le sens de la dependance.
+ */
+export interface ChampDAdresse {
+  /** Le pays choisi (code ISO), ou `''` : la recherche s'y restreint. */
+  readonly pays: Signal<string>;
+  /** Ni desactive, ni en lecture seule : une recherche inerte sinon. */
+  readonly modifiable: Signal<boolean>;
+  /**
+   * Reporte une adresse trouvee dans les champs. Le complement deja saisi est garde quand
+   * l'adresse n'en porte pas : aucun service ne connait l'appartement.
+   */
+  remplir(adresse: Adresse): void;
+  /** Annonce polie, dans la region unique du champ. */
+  annoncer(message: string): void;
+}
+export declare const ST_CHAMP_D_ADRESSE: InjectionToken<ChampDAdresse>;
+/** Ce qui decide des options d'une liste de pays (`optionsDesPays`). */
+export interface ParametresDesPays {
+  /** La langue des noms et de leur tri (`ST_LOCALE`). */
+  readonly locale: string;
+  /** Les pays proposes (codes ISO) ; `null` : les 249 pays de la norme. */
+  readonly codes: readonly string[] | null;
+  /** Les pays frequents, en tete de liste et dans cet ordre. */
+  readonly enTete: readonly string[];
+  /** Le code du modele : nomme et desactive quand il n'est pas propose. */
+  readonly courant: string | null;
+  /** Les intitules des deux groupes (« Pays frequents », « Tous les pays »). */
+  readonly groupes: {
+    readonly frequents: string;
+    readonly tous: string;
+  };
+}
+/**
+ * Les options d'une liste de pays, partagees par `st-country-field` (select natif) et
+ * `st-country-combobox` (`@starterlib/ui/selection`, filtrable) : noms par `Intl` dans la langue
+ * donnee, tries par sa collation ; les pays frequents dans un premier groupe, sans etre repetes
+ * dans le second ; un pays du modele hors de la liste en tete, nomme et desactive, jamais tu.
+ */
+export declare function optionsDesPays(parametres: ParametresDesPays): OptionDeListe[];
+/**
+ * Liste des pays : un `select` natif (`st-select`), la valeur est le code ISO 3166-1 alpha-2.
+ *
+ * ```html
+ * <st-country-field libelle="Pays" [enTete]="['FR', 'BE', 'CH']" [formField]="f.pays" />
+ * ```
+ *
+ * ⚠️ **Les noms viennent d'`Intl`, dans la langue de la page** (`ST_LOCALE`), et se trient par sa
+ * collation : aucune liste de noms n'est ecrite dans le socle, aucune ne reste en francais quand
+ * la page passe en anglais. Le code ISO ne s'affiche jamais.
+ *
+ * `codes` restreint la liste (zone SEPA, pays admis) ; `enTete` place les pays frequents dans un
+ * premier groupe, sans les repeter dans le second. `autocomplete="country"` par defaut : le
+ * navigateur remplit le champ (WCAG 1.3.5).
+ *
+ * ⚠️ **Un pays deja dans le modele et absent de `codes` ne disparait pas** : il reste affiche,
+ * nomme et desactive ; `erreurPays` du schema dit pourquoi il ne passe pas.
+ */
+export declare class StCountryField extends ControleDeSaisie {
+  private readonly libelles;
+  private readonly locale;
+  /** Les pays proposes (codes ISO) ; absent : les 249 pays de la norme. */
+  readonly codes: import("@angular/core").InputSignal<readonly string[] | null>;
+  /** Les pays frequents, en tete de liste et dans cet ordre. */
+  readonly enTete: import("@angular/core").InputSignal<readonly string[]>;
+  /** WCAG 1.3.5 : `country` par defaut ; `shipping country` dans un formulaire de livraison. */
+  readonly autocomplete: import("@angular/core").InputSignal<TypeDAutocompletion | null>;
+  /** Texte de l'option vide. Par defaut : « Choisir… ». */
+  readonly texteVide: import("@angular/core").InputSignal<string | null>;
+  /** Le style de l'etiquette (voir `st-form-field`). */
+  readonly presentation: import("@angular/core").InputSignal<PresentationDeLibelle>;
+  private readonly liste;
+  protected readonly options: import("@angular/core").Signal<OptionDeListe[]>;
+  /** Signal Forms amene le focus sur le `select` interne. */
+  focus(options?: FocusOptions): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCountryField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StCountryField, "st-country-field", never, {
+    "codes": {
+      "alias": "codes";
+      "required": false;
+      "isSignal": true;
+    };
+    "enTete": {
+      "alias": "enTete";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "texteVide": {
+      "alias": "texteVide";
+      "required": false;
+      "isSignal": true;
+    };
+    "presentation": {
+      "alias": "presentation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Ce que la region affiche : sa liste fermee (`liste`), la sienne en chemin (`chargement`), un texte
+ * libre faute de liste pour le pays (`texte`), ou faute de liste servie (`panne`, et elle le dit).
+ */
+export type ModeDeRegion = 'liste' | 'chargement' | 'texte' | 'panne';
+type PartieDeTexte = Exclude<PartieDAdresse, 'pays'>;
+/**
+ * Adresse postale, en un groupe : le pays d'abord, puis les champs que son format postal emploie,
+ * dans son ordre, avec ses libelles et ses exigences.
+ *
+ * ```html
+ * <st-address-fieldset libelle="Adresse de residence" [formField]="formulaire.adresse">
+ *   <st-address-search />   <!-- facultative : @starterlib/ui/selection -->
+ * </st-address-fieldset>
+ * ```
+ *
+ * ```ts
+ * required(chemin.adresse);
+ * validate(chemin.adresse, ({ value }) => erreursDAdresse(value()));
+ * ```
+ *
+ * ⚠️ **Dynamique par pays** (`formatDAdresse` d'`@starterlib/util`) : le code postal avant la
+ * ville en France, apres elle au Canada, absent au Cameroun ; la region nommee « Province ou
+ * territoire », « Etat » ou « Comte », exigee ou non. Changer de pays ne deplace jamais le focus
+ * (WCAG 3.2.2) ; un format qui change s'annonce poliment. Les parties que le nouveau format
+ * n'affiche plus sont VIDEES : aucune donnee cachee ne part avec le formulaire.
+ *
+ * ⚠️ **Un jeton de remplissage exact par champ** (WCAG 1.3.5) : `address-line1`, `address-line2`,
+ * `postal-code`, `address-level2`, `address-level1`, `country` ; `sectionDeRemplissage` les
+ * prefixe (`shipping`, `billing`) quand deux adresses partagent un formulaire. Le remplissage du
+ * navigateur marche sans la recherche, et la rend inutile a qui l'emploie.
+ *
+ * ⚠️ **La valeur est toujours un objet** (`Adresse`, six chaines) : `required` du schema ne peut
+ * donc pas la dire vide. Ce sont les erreurs de `erreursDAdresse`, une par partie (cle `partie`),
+ * qui bloquent l'envoi ; chacune s'affiche sous son champ, et `focus()` va a la premiere.
+ * L'obligation se lit sur chaque champ exige, jamais sur le complement.
+ *
+ * Une recherche projetee (`st-address-search`) remplit les champs par `ST_CHAMP_D_ADRESSE` ; le
+ * complement deja saisi n'est jamais efface.
+ *
+ * ⚠️ **Listes par pays** (`ST_LISTES_D_ADRESSES`, ADR 0005 D133), quand l'hote en relie une source :
+ * la region devient une liste FERMEE des regions du pays (`st-select`, chargee a chaque pays), la
+ * ville un texte a valeurs PROPOSEES, celles du pays ou de la region choisie (une localite peut
+ * manquer a toute liste : rien n'est refuse). Un pays sans liste garde la region en texte libre ;
+ * une liste qui ne se charge pas aussi, et l'aide de la region le dit. Une region rapportee par son
+ * nom (« Ontario ») s'ecrit a la valeur de sa liste (« ON ») ; une valeur que la liste ne porte pas
+ * reste affichee, nommee, jamais tue. Une region choisie dans la liste d'un pays s'efface quand le
+ * pays change ; une region tapee reste, a corriger.
+ */
+export declare class StAddressFieldset extends ContratDeChamp implements FormValueControl<Adresse> {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  private readonly element;
+  readonly value: import("@angular/core").ModelSignal<Adresse>;
+  /** Un pays impose (code ISO) : le champ pays disparait, la valeur le porte. */
+  readonly paysFixe: import("@angular/core").InputSignal<string | null>;
+  /** Les pays admis (codes ISO) ; absent : les 249 pays de la norme. */
+  readonly codesDesPays: import("@angular/core").InputSignal<readonly string[] | null>;
+  /** Les pays frequents, en tete de la liste. */
+  readonly paysFrequents: import("@angular/core").InputSignal<readonly string[]>;
+  /** Sans complement d'adresse (une ligne de voie seulement). */
+  readonly ligne2Masquee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Prefixe des jetons de remplissage (`shipping`, `billing`, `section-<nom>`), quand deux
+   * adresses partagent un formulaire. `null` : les jetons seuls.
+   */
+  readonly sectionDeRemplissage: import("@angular/core").InputSignal<string | null>;
+  protected readonly annonce: AnnonceLocale;
+  private readonly listes;
+  /** Le pays qui decide du format : l'impose, sinon celui de la valeur. */
+  private readonly pays;
+  protected readonly format: import("@angular/core").Signal<FormatDAdresse>;
+  protected readonly parties: import("@angular/core").Signal<PartieDeTexte[]>;
+  private readonly exigees;
+  protected readonly modifiable: import("@angular/core").Signal<boolean>;
+  /** Les erreurs du schema, par partie ; celles sans partie restent au groupe. */
+  private readonly erreursParPartie;
+  protected readonly erreursDuGroupe: import("@angular/core").Signal<ErreurAffichable[]>;
+  /** La liste des regions a demander : le pays, s'il affiche une region et qu'une source existe. */
+  private readonly demandeDeRegions;
+  private readonly regions;
+  /** Les regions du pays, une fois servies ; `null` sans liste. */
+  private readonly listeDesRegions;
+  protected readonly modeDeRegion: import("@angular/core").Signal<ModeDeRegion>;
+  protected readonly regionEnListe: import("@angular/core").Signal<boolean>;
+  /** Les options de la region : sa liste, et la valeur du modele qu'elle ne porte pas, nommee. */
+  protected readonly optionsDeRegion: import("@angular/core").Signal<OptionDeListe[]>;
+  /** Les villes a demander : le pays, et la region seulement si sa liste la porte. */
+  private readonly demandeDeVilles;
+  private readonly villes;
+  /** Les villes proposees sous le champ ; une liste en panne n'en propose aucune, sans rien bloquer. */
+  protected readonly villesProposees: import("@angular/core").Signal<readonly string[] | null>;
+  private readonly listeDesPays;
+  constructor();
+  protected erreursDe(partie: PartieDAdresse): readonly ErreurAffichable[];
+  protected libelleDe(partie: PartieDeTexte): string;
+  protected aideDe(partie: PartieDeTexte): string | null;
+  protected exigee(partie: PartieDAdresse): boolean;
+  protected jeton(partie: PartieDAdresse): TypeDAutocompletion;
+  protected clavier(partie: PartieDeTexte): ModeDeSaisie | null;
+  protected nomDe(partie: PartieDAdresse): string;
+  protected changer(partie: PartieDeTexte, texte: string): void;
+  protected changerDePays(code: string): void;
+  /** A la sortie du code postal : capitales, espaces reduites (« h2x  1y4 » donne « H2X 1Y4 »). */
+  protected aLaSortieDe(partie: PartieDeTexte): void;
+  /** `touch` quand le focus quitte le groupe entier, et non chaque champ. */
+  protected aLaSortie(evenement: FocusEvent): void;
+  /**
+   * Appele par Signal Forms pour amener le focus sur un champ en erreur : la PREMIERE partie en
+   * erreur, dans l'ordre du champ (le pays d'abord), sinon le premier champ.
+   */
+  focus(options?: FocusOptions): void;
+  private remplir;
+  /** Vide les parties que le format du pays n'affiche pas : rien de cache ne part. */
+  private nettoyer;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StAddressFieldset, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StAddressFieldset, "st-address-fieldset", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "paysFixe": {
+      "alias": "paysFixe";
+      "required": false;
+      "isSignal": true;
+    };
+    "codesDesPays": {
+      "alias": "codesDesPays";
+      "required": false;
+      "isSignal": true;
+    };
+    "paysFrequents": {
+      "alias": "paysFrequents";
+      "required": false;
+      "isSignal": true;
+    };
+    "ligne2Masquee": {
+      "alias": "ligne2Masquee";
+      "required": false;
+      "isSignal": true;
+    };
+    "sectionDeRemplissage": {
+      "alias": "sectionDeRemplissage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
 }
 
-export { ContratDeChamp, ControleDeSaisie, StCalendar, StCheckbox, StControleDeChamp, StErrorSummary, StFieldset, StFileUpload, StFormField, StIbanField, StInput, StOtpField, StPasswordField, StPhoneField, StRadioGroup, StSearchField, StSelect, StSwitch, StTextarea, cleDeFichier, erreurDate, erreurIban, erreurPlageDeDates, erreurTelephone, erreursDeFichiers, exempleDeDate, filtrerOptions, fusionnerErreurs, messageDErreur, motifLocal, normaliserPourRecherche };
-export type { BornesDeDate, DispositionDeChamp, ElementDeSaisie, ErreurAffichable, EtatDeTeleversementAffiche, OptionDeListe, OptionRadio, ReglesDeFichiers, RemplissageDeTelephone, TypeDeSaisie, UsageDuMotDePasse };
+export {};