@starterlib/ui 0.8.0 → 0.9.1

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

@@ -1,76 +1,174 @@
-import * as _angular_core from '@angular/core';
-import { InjectionToken, Type, TemplateRef, Signal } from '@angular/core';
-import * as i1 from '@angular/aria/menu';
-import { Ton, TonSemantique } from '@starterlib/util';
-import { NomDIcone, AnnonceLocale } from '@starterlib/ui';
-import { CdkDialogContainer } from '@angular/cdk/dialog';
-export { DIALOG_DATA as DONNEES_DE_DIALOGUE } from '@angular/cdk/dialog';
-
-type AlignementDeMenu = 'debut' | 'fin';
+import * as i0 from "@angular/core";
+import { InjectionToken, OnInit, Signal, TemplateRef, Type } from "@angular/core";
+import * as i1 from "@angular/aria/menu";
+import { Ton, TonSemantique, sansCommandesDeDirection, texteDUneLigne } from "@starterlib/util";
+import { AnnonceLocale, Icone, NomDIcone, TailleDeBouton, VarianteDeBouton } from "@starterlib/ui";
+import { CdkDialogContainer, DIALOG_DATA, DialogConfig } from "@angular/cdk/dialog";
+export type AlignementDeMenu = 'debut' | 'fin';
+/**
+ * `detachee` (defaut du socle) : le menu flotte a 4 px de son declencheur, rayon et filet
+ * complets. `collee` (planche 5, module 5.4) : le menu prolonge son declencheur, sans ecart, au
+ * moins aussi large que lui ; les coins qui se touchent sont carres, des deux cotes.
+ */
+export type AccrocheDeMenu = 'detachee' | 'collee';
+/**
+ * L'element focalise a l'ouverture : le premier (clic, Entree, Espace, Fleche bas) ou le dernier
+ * (Fleche haut).
+ */
+export type EntreeFocaliseeALOuverture = 'premier' | 'dernier';
 /**
  * Menu d'actions. Le declencheur le designe, comme chez Material :
  *
  * ```html
- * <button stMenuTrigger [menu]="compte" stButton>Actions</button>
+ * <button stButton [stMenuTrigger]="compte">Actions</button>
  *
  * <st-menu #compte etiquette="Compte" (selection)="agir($event)">
  *   <button stMenuItem valeur="profil">Mon profil</button>
- *   <button stMenuItem valeur="quitter" ton="destructeur">Se deconnecter</button>
+ *   <hr stMenuSeparator />
+ *   <button stMenuItem valeur="quitter" ton="danger">Se deconnecter</button>
  * </st-menu>
  * ```
  *
+ * Motif APG « menu button », tenu de bout en bout (lot 231) :
+ *
+ * - a l'ouverture, le focus va au PREMIER element (clic, Entree, Espace, Fleche bas) ou au
+ *   DERNIER (Fleche haut), jamais au conteneur : le lecteur d'ecran annonce l'element, et la
+ *   fleche suivante atteint le deuxieme ;
+ * - Echap ferme et rend le focus au declencheur ; la selection aussi ;
+ * - Tab ferme : le focus revient au declencheur et la tabulation repart de lui (le menu vit en
+ *   fin de document, dans la couche : sans cela, Tab sortait de la page) ;
+ * - un focus pose ailleurs (clic, script) ferme SANS reprendre le focus ;
+ * - un second clic sur le declencheur ferme (garde de `CoucheAncree`) ;
+ * - le declencheur porte `aria-controls` vers l'identifiant du menu.
+ *
  * ⚠️ Pourquoi le declencheur est DEHORS et les elements DEDANS. La primitive
  * `Menu` d'`@angular/aria` relie ses elements au menu par injection, et un
  * contenu projete garde l'injecteur de l'endroit ou il est ECRIT — jamais celui
  * qui le rend. Les elements doivent donc etre ecrits a l'interieur de l'element
  * qui porte le menu, sans quoi ils ne s'y enregistrent pas : le clavier ne
  * bouge plus, et rien ne le signale. Le declencheur, lui, n'a rien a faire dans
- * un `role="menu"`, qui ne contient que des elements de menu.
- *
- * Le clavier vient d'Aria, le placement du CDK. Le socle n'ecrit ni l'un ni
- * l'autre : deux motifs longs, que l'on croit finis avant de les avoir
- * eprouves au lecteur d'ecran ou au bord de l'ecran.
+ * un `role="menu"`, qui ne contient que des elements de menu et des separateurs.
  *
  * ⚠️ A l'ouverture, l'element est DEPLACE dans la couche d'overlay
  * (`DomPortal`), il n'est pas recree : ses liaisons, son etat et son injecteur
  * survivent au passage, ce qu'un gabarit reconstruit perdrait.
  */
-declare class StMenu {
-    private readonly element;
-    private readonly overlay;
-    private readonly aria;
-    /** Nom du menu pour les technologies d'assistance. */
-    readonly etiquette: _angular_core.InputSignal<string>;
-    readonly alignement: _angular_core.InputSignal<AlignementDeMenu>;
-    private readonly ouvertInterne;
-    readonly ouvert: _angular_core.Signal<boolean>;
-    private couche;
-    private declencheur;
-    constructor();
-    ouvrirDepuis(declencheur: HTMLElement): void;
-    /**
-     * Ferme, et rend le focus au declencheur : sans cela, le focus retombe sur le
-     * corps du document, et la navigation clavier reprend en haut de page.
-     */
-    fermer(options?: {
-        readonly rendreLeFocus?: boolean;
-    }): void;
-    basculerDepuis(declencheur: HTMLElement): void;
-    protected auClavier(evenement: KeyboardEvent): void;
-    private detruireLaCouche;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StMenu, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StMenu, "st-menu", never, { "etiquette": { "alias": "etiquette"; "required": true; "isSignal": true; }; "alignement": { "alias": "alignement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Menu; inputs: { "wrap": "wrap"; "typeaheadDelay": "typeaheadDelay"; "disabled": "disabled"; }; outputs: { "itemSelected": "selection"; }; }]>;
-}
-
+export declare class StMenu {
+  private readonly element;
+  private readonly aria;
+  private readonly couche;
+  /** Nom du menu pour les technologies d'assistance. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  readonly alignement: import("@angular/core").InputSignal<AlignementDeMenu>;
+  /** `detachee` (defaut) ou `collee` au declencheur (planche 5). */
+  readonly accroche: import("@angular/core").InputSignal<AccrocheDeMenu>;
+  private readonly ouvertInterne;
+  readonly ouvert: import("@angular/core").Signal<boolean>;
+  private declencheur;
+  /**
+   * Vrai quand CE menu a pose `data-accroche-menu` sur son declencheur (ouvert par script depuis
+   * un element sans `stMenuTrigger`) : il ne retire a la fermeture que ce qu'il a pose. Sous
+   * `stMenuTrigger`, la marque est permanente (D53) et appartient a la directive.
+   */
+  private accrochePosee;
+  /**
+   * Garde du survol apres une ouverture AU CLAVIER : `attente` jusqu'au premier survol, puis la
+   * position du pointeur a ce moment-la. Un menu qui s'ouvre sous un pointeur immobile recoit un
+   * `mouseover` (Chromium le rejoue apres la mise en page), et la primitive y deplace le focus :
+   * la fleche haut ouvrait sur le dernier element, et le focus sautait au premier. Seul un
+   * pointeur qui BOUGE rend la main au survol.
+   */
+  private gardeDuSurvol;
+  constructor();
+  /** Identifiant du menu (celui de la primitive), que le declencheur pose en `aria-controls`. */
+  identifiant(): string;
+  /**
+   * Ouvre depuis `declencheur`, le focus sur le premier ou le dernier element. `parClavier` :
+   * ouvert par une touche (fleches, Entree, Espace) ; le survol d'un pointeur immobile ne deplace
+   * alors pas le focus.
+   */
+  ouvrirDepuis(declencheur: HTMLElement, focus?: EntreeFocaliseeALOuverture, parClavier?: boolean): void;
+  /**
+   * Ferme, et rend le focus au declencheur : sans cela, le focus retombe sur le
+   * corps du document, et la navigation clavier reprend en haut de page.
+   *
+   * ⚠️ Le focus est rendu A LA DEMANDE, pas a la fin du fondu (03 §2.6 c) : au
+   * clavier, on ne fait pas attendre 120 ms. La couche, elle, part en fondu et
+   * n'est detachee qu'a la fin de sa transition — dans la meme tache quand la
+   * duree vaut zero. Un focus que la personne a pose ailleurs n'est jamais repris.
+   */
+  fermer(options?: {
+    readonly rendreLeFocus?: boolean;
+  }): void;
+  basculerDepuis(declencheur: HTMLElement, parClavier?: boolean): void;
+  protected auClavier(evenement: KeyboardEvent): void;
+  private filtrerLeSurvol;
+  /** Un `pointermove` a des coordonnees differentes de la garde : le pointeur a VRAIMENT bouge. */
+  private libererLaGardeAuMouvement;
+  /** Un focus pose HORS du menu et hors du declencheur ferme, sans le reprendre. */
+  protected aLaPerteDuFocus(evenement: FocusEvent): void;
+  /** Accroche collee : le declencheur retrouve ses coins en meme temps que le menu se ferme. */
+  private oublierLeDeclencheur;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMenu, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMenu, "st-menu", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "alignement": {
+      "alias": "alignement";
+      "required": false;
+      "isSignal": true;
+    };
+    "accroche": {
+      "alias": "accroche";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, [{
+    directive: typeof i1.Menu;
+    inputs: {
+      "wrap": "wrap";
+      "typeaheadDelay": "typeaheadDelay";
+      "disabled": "indisponible";
+    };
+    outputs: {
+      "itemSelected": "selection";
+    };
+  }]>;
+}
 /**
  * ⚠️ `danger` et non « destructeur » : c'est le meme rouge, la meme intention,
  * et l'appelant ne doit pas avoir a se souvenir que le menu, LUI, a son mot.
+ *
+ * `danger-discret` (lot 265, EA-234) : la SORTIE (« Se deconnecter » du menu de compte), sur le
+ * papier danger discret des le repos ; pas une destruction, donc sans confirmation.
+ */
+export type TonDElementDeMenu = Extract<Ton, 'neutre' | 'danger'> | 'danger-discret';
+/**
+ * Entree a etat : `case` (menuitemcheckbox, independante) ou `radio` (menuitemradio, une parmi
+ * ses voisines). Sans choix, l'entree est une action (`menuitem`).
+ *
+ * ⚠️ `radio` est RESERVE a un vrai groupe exclusif (au moins deux entrees `radio` voisines, une
+ * seule cochee a la fois) : ARIA definit `menuitemradio` comme membre d'un ensemble. Un reglage
+ * a bascule seul (« Afficher les archives », coche ou non) est un `case`, jamais un `radio` isole
+ * (revue E12).
  */
-type TonDElementDeMenu = Extract<Ton, 'neutre' | 'danger'>;
+export type ChoixDElementDeMenu = 'case' | 'radio';
 /**
  * Element de menu, pose en ATTRIBUT sur un `<button>` natif — meme raison que
  * `st-button` : une enveloppe casserait le comportement natif du bouton.
  *
+ * ```html
+ * <button stMenuItem valeur="dupliquer" icone="copie">Dupliquer</button>
+ * <button stMenuItem valeur="xml" icone="telecharger" choix="radio" coche>
+ *   Exporter <span suffixe>XML</span>
+ * </button>
+ * <hr stMenuSeparator />
+ * <button stMenuItem valeur="annuler" icone="corbeille" ton="danger">Annuler</button>
+ * ```
+ *
  * Le clavier (fleches, Debut, Fin, saisie au vol, indice de tabulation
  * glissant) vient de la primitive `MenuItem` d'`@angular/aria`, composee en
  * directive d'hote. Le socle n'en reecrit aucune part : ces motifs sont longs a
@@ -80,96 +178,493 @@ type TonDElementDeMenu = Extract<Ton, 'neutre' | 'danger'>;
  * defaut : c'est elle que `st-menu` emet a la selection. Un menu dont les
  * elements n'ont pas d'identite stable oblige l'appelant a distinguer ses
  * actions par leur libelle, donc par leur traduction.
+ *
+ * ⚠️ `choix` et non `type` : `type="button"` est l'attribut NATIF du bouton, qu'une entree
+ * nommee `type` aurait capture.
+ *
+ * `[suffixe]` : un complement court en fin de ligne (format, raccourci), en chasse fixe et en
+ * capitales ; il fait partie du nom accessible de l'entree.
  */
-declare class StMenuItem {
-    readonly icone: _angular_core.InputSignal<"boite-vide" | "calendrier" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "fichier" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "televerser" | "tri" | "triangle-alerte" | "utilisateur" | null>;
-    readonly ton: _angular_core.InputSignal<TonDElementDeMenu>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StMenuItem, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StMenuItem, "button[stMenuItem]", never, { "icone": { "alias": "icone"; "required": false; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.MenuItem; inputs: { "value": "valeur"; "disabled": "desactive"; "role": "role"; }; outputs: {}; }]>;
+export declare class StMenuItem {
+  private readonly aria;
+  readonly icone: import("@angular/core").InputSignal<Icone | null>;
+  readonly ton: import("@angular/core").InputSignal<TonDElementDeMenu>;
+  /** Entree a etat (case ou radio) ; `null` : une action. */
+  readonly choix: import("@angular/core").InputSignal<ChoixDElementDeMenu | null>;
+  /** Etat d'une entree `choix` : `aria-checked`, et le rendu choisi (fond, graisse, icone). */
+  readonly coche: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * ⚠️ Pose APRES la liaison de la primitive (celle de l'hote l'emporte) : sans `choix`, le role
+   * reste celui que la primitive tient, jamais `null`, qui retirerait l'attribut.
+   */
+  protected readonly roleLu: import("@angular/core").Signal<"menuitemcheckbox" | "menuitemradio" | "menuitem">;
+  protected readonly cocheLu: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMenuItem, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMenuItem, "button[stMenuItem]", never, {
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "choix": {
+      "alias": "choix";
+      "required": false;
+      "isSignal": true;
+    };
+    "coche": {
+      "alias": "coche";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*", "[suffixe]"], true, [{
+    directive: typeof i1.MenuItem;
+    inputs: {
+      "value": "valeur";
+      "disabled": "desactive";
+      "role": "role";
+    };
+    outputs: {};
+  }]>;
 }
-
 /**
  * Controle qui ouvre un menu. Il le DESIGNE, il ne le contient pas :
  *
  * ```html
- * <button stMenuTrigger [menu]="compte" stButton>Actions</button>
+ * <button stButton [stMenuTrigger]="compte">Actions</button>
  * <st-menu #compte etiquette="Compte">…</st-menu>
  * ```
  *
+ * Meme convention de designation que `[stPopoverTrigger]="couche"` (lot 228) : le menu se
+ * passe a l'attribut lui-meme, et il est requis.
+ *
+ * Le declencheur porte `aria-haspopup="menu"`, `aria-expanded` et `aria-controls` (l'identifiant
+ * du menu) ; la fleche bas ouvre sur le premier element, la fleche haut sur le dernier.
+ *
+ * ⚠️ `type="button"` est FORCE sur un `<button>` : dans un formulaire, un declencheur sans type
+ * est un bouton d'envoi, et ouvrir un menu soumettait le formulaire.
+ *
  * ⚠️ Le type de `menu` est importe en TYPE seulement : `st-menu` n'a pas besoin
  * de cette directive, et l'importer dans les deux sens formerait un cycle.
  */
-declare class StMenuTrigger {
-    private readonly element;
-    readonly menu: _angular_core.InputSignal<StMenu>;
-    protected basculer(): void;
-    protected auClavier(evenement: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StMenuTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StMenuTrigger, "[stMenuTrigger]", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class StMenuTrigger {
+  private readonly element;
+  /**
+   * ⚠️ Pose `type="button"` UNE FOIS, imperativement, jamais par `[attr.type]` : une liaison
+   * d'attribut hote part d'un etat non initialise et vaut `null` hors `<button>`, or Angular
+   * appelle `removeAttribute` des le premier passage pour une liaison a `null` — un
+   * `<input type="button">` perdait son `type` (redevenait un champ texte), et un
+   * `<button type="submit">` ecrit par l'auteur voyait son type ecrase en silence. On ne pose
+   * donc rien hors `<button>`, et jamais par-dessus un type deja explicite.
+   */
+  constructor();
+  /** Le menu ouvert par ce controle : `[stMenuTrigger]="menu"`. */
+  readonly stMenuTrigger: import("@angular/core").InputSignal<StMenu>;
+  /** Le menu designe. */
+  protected readonly cible: import("@angular/core").Signal<StMenu>;
+  /**
+   * D53 : le declencheur d'un menu COLLE garde sa disposition (libelle au debut, fleche en fin de
+   * ligne, largeur du panneau) ferme comme ouvert : la marque est posee EN PERMANENCE, jamais le
+   * temps de l'ouverture seulement, sans quoi le bouton changeait de forme au clic. Le cote
+   * (`data-menu-cote`, coins et fleche retournee) reste pose par le menu, ouvert seulement.
+   */
+  protected readonly accrocheLue: import("@angular/core").Signal<"collee" | null>;
+  /**
+   * Vrai quand l'element est indisponible, natif (`:disabled`) ou logiciel (`aria-disabled`,
+   * pose par `stButton indisponible`). Aucun de ses evenements n'ouvre alors le menu : le clic
+   * est deja avale par la garde de `stButton`, mais les fleches (ci-dessous) ne passaient pas
+   * par elle et ouvraient quand meme le menu au clavier.
+   */
+  private estIndisponible;
+  /** `detail === 0` : un clic produit par Entree ou Espace, donc une ouverture au clavier. */
+  protected basculer(evenement: MouseEvent): void;
+  /**
+   * Fleche bas : ouvre sur le PREMIER element ; fleche haut : sur le DERNIER (APG « menu
+   * button »). Entree et Espace passent par le clic natif du bouton, qui ouvre sur le premier.
+   */
+  protected auClavier(evenement: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMenuTrigger, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StMenuTrigger, "[stMenuTrigger]", never, {
+    "stMenuTrigger": {
+      "alias": "stMenuTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Separateur d'un menu, pose sur un `<hr>` natif : son role `separator` est IMPLICITE, et c'est
+ * l'un des deux enfants qu'un `role="menu"` admet (avec les elements de menu). Il ne prend pas le
+ * focus et la primitive d'Aria ne le compte pas : les fleches le sautent.
+ *
+ * ```html
+ * <button stMenuItem valeur="imprimer" icone="imprimer">Imprimer</button>
+ * <hr stMenuSeparator />
+ * <button stMenuItem valeur="annuler" icone="corbeille" ton="danger">Annuler</button>
+ * ```
+ *
+ * R13 : l'entree `danger` vient en dernier, apres un separateur ; jamais plus de huit entrees
+ * sans separateur.
+ */
+export declare class StMenuSeparator {
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMenuSeparator, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMenuSeparator, "hr[stMenuSeparator]", never, {}, {}, never, never, true, never>;
+}
+/** Les fonds d'un bouton scinde : ceux que le bouton-icone du chevron sait aussi prendre. */
+export type VarianteDeBoutonScinde = Extract<VarianteDeBouton, 'primaire' | 'secondaire' | 'tonale'>;
+/** Les tailles communes au bouton et au bouton-icone : un groupe attache n'en melange pas deux. */
+export type TailleDeBoutonScinde = Extract<TailleDeBouton, 'sm' | 'md'>;
+/**
+ * Le bouton scinde (lot 265) : une action directe et, colle a elle, le menu de ses variantes
+ * (« Enregistrer », et « Enregistrer et fermer », « Enregistrer comme modele »).
+ *
+ * ```html
+ * <st-split-button libelle="Enregistrer" type="submit" [menu]="variantes" (action)="…" />
+ * <st-menu #variantes etiquette="Autres enregistrements" alignement="fin" (selection)="…">
+ *   <button stMenuItem valeur="fermer">Enregistrer et fermer</button>
+ * </st-menu>
+ * ```
+ *
+ * - DEUX boutons distincts dans un `st-button-group` attache : l'action (qui peut envoyer son
+ *   formulaire), puis le chevron, un bouton de menu APG nomme « Plus d'options pour Enregistrer »
+ *   (`aria-haspopup`, `aria-expanded`, `aria-controls` par `[stMenuTrigger]`). Deux arrets de
+ *   tabulation, deux anneaux de focus entiers : le focalise passe au-dessus de son voisin.
+ * - Chargement et indisponibilite gagnent les deux : pendant l'envoi, le chevron se tait aussi.
+ * - Le menu est ecrit a cote par l'application, comme pour tout `[stMenuTrigger]`.
+ */
+export declare class StSplitButton {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  /** Le libelle de l'action, deja traduit : visible, il nomme le groupe et le second bouton. */
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  /** Le menu des variantes de l'action. */
+  readonly menu: import("@angular/core").InputSignal<StMenu>;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeBoutonScinde>;
+  readonly taille: import("@angular/core").InputSignal<TailleDeBoutonScinde>;
+  /** `submit` : l'action envoie son formulaire ; le chevron reste un `button`. */
+  readonly type: import("@angular/core").InputSignal<"submit" | "button">;
+  readonly iconeAvant: import("@angular/core").InputSignal<Icone | null>;
+  /** Le nom du chevron ; defaut : « Plus d'options pour {libelle} ». */
+  readonly etiquetteDuMenu: import("@angular/core").InputSignal<string | null>;
+  readonly chargement: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly indisponible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le clic de l'action (un `submit` envoie aussi son formulaire). */
+  readonly action: import("@angular/core").OutputEmitterRef<MouseEvent>;
+  protected readonly nomDuMenu: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSplitButton, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSplitButton, "st-split-button", never, {
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "menu": {
+      "alias": "menu";
+      "required": true;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "taille": {
+      "alias": "taille";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconeAvant": {
+      "alias": "iconeAvant";
+      "required": false;
+      "isSignal": true;
+    };
+    "etiquetteDuMenu": {
+      "alias": "etiquetteDuMenu";
+      "required": false;
+      "isSignal": true;
+    };
+    "chargement": {
+      "alias": "chargement";
+      "required": false;
+      "isSignal": true;
+    };
+    "indisponible": {
+      "alias": "indisponible";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "action": "action";
+  }, never, never, true, never>;
+}
+/** Une entree du menu de compte : sa valeur (emise a la selection), son libelle traduit. */
+export interface ElementDeMenuDeCompte {
+  readonly valeur: string;
+  readonly libelle: string;
+  readonly icone?: Icone | null;
+}
+/**
+ * Le menu de compte (lot 265), qui remplace « avatar + Se deconnecter » ecrits en clair dans
+ * l'en-tete : profil, preferences, securite, puis la deconnexion.
+ *
+ * ```html
+ * <st-user-menu [nom]="nom()" fonction="Superviseur reseau" [elements]="entrees"
+ *   (selection)="naviguer($event)" (deconnexion)="session.deconnecter()" />
+ * ```
+ *
+ * - PRESENTATION PURE : il n'injecte pas `@starterlib/core` (ADR 0003) ; la session, la navigation
+ *   et la deconnexion appartiennent a l'application, qui recoit `selection` et `deconnexion`.
+ * - Le declencheur est un bouton de menu APG nomme « Compte de {nom} » (le nom visible y est
+ *   contenu, WCAG 2.5.3) : l'avatar, le nom (masque sous `md`), un chevron qui pivote a
+ *   l'ouverture.
+ * - L'en-tete du panneau (avatar, nom, fonction, courriel) n'est pas une entree : muet dans le
+ *   menu, il le DECRIT (`aria-describedby`). Les entrees sont des `stMenuItem` ; la deconnexion
+ *   vient en dernier, apres un separateur, en danger discret (EA-234) : une sortie, pas une
+ *   destruction, donc sans confirmation.
+ */
+export declare class StUserMenu {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  protected readonly deconnecter = "st-user-menu:deconnexion";
+  /** Prenom et nom tels qu'affiches. */
+  readonly nom: import("@angular/core").InputSignal<string>;
+  /** La fonction ou le role metier (« Superviseur reseau ») ; jamais un droit technique. */
+  readonly fonction: import("@angular/core").InputSignal<string | null>;
+  readonly courriel: import("@angular/core").InputSignal<string | null>;
+  /** La photo ; sans elle, les initiales. */
+  readonly image: import("@angular/core").InputSignal<string | null>;
+  readonly elements: import("@angular/core").InputSignal<readonly ElementDeMenuDeCompte[]>;
+  /** La valeur de l'entree choisie. */
+  readonly selection: import("@angular/core").OutputEmitterRef<string>;
+  readonly deconnexion: import("@angular/core").OutputEmitterRef<void>;
+  /**
+   * Nom, fonction et courriel sont des donnees : sans commande de direction, et isoles par leur
+   * element dans le gabarit, le courriel de gauche a droite. Le nom l'est partout, jusque dans le
+   * nom du compte (l'elision lit sa premiere lettre) et les initiales des avatars (audit UI du
+   * 2026-09-27, D-5).
+   */
+  protected readonly affichable: typeof sansCommandesDeDirection;
+  protected readonly nomAffiche: import("@angular/core").Signal<string>;
+  protected readonly nomDuCompte: import("@angular/core").Signal<string>;
+  protected readonly idDeLEntete: string;
+  protected choisir(valeur: unknown): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StUserMenu, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StUserMenu, "st-user-menu", never, {
+    "nom": {
+      "alias": "nom";
+      "required": true;
+      "isSignal": true;
+    };
+    "fonction": {
+      "alias": "fonction";
+      "required": false;
+      "isSignal": true;
+    };
+    "courriel": {
+      "alias": "courriel";
+      "required": false;
+      "isSignal": true;
+    };
+    "image": {
+      "alias": "image";
+      "required": false;
+      "isSignal": true;
+    };
+    "elements": {
+      "alias": "elements";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selection": "selection";
+    "deconnexion": "deconnexion";
+  }, never, never, true, never>;
 }
-
 /** Une action secondaire, decrite par l'appelant. Le libelle est deja traduit. */
-interface ActionDeBarre {
-    /** Identite stable, emise a l'activation : jamais le libelle, donc jamais la traduction. */
-    readonly valeur: string;
-    readonly libelle: string;
-    readonly icone?: NomDIcone;
-    readonly ton?: TonDElementDeMenu;
-    readonly desactive?: boolean;
+export interface ActionDeBarre {
+  /** Identite stable, emise a l'activation : jamais le libelle, donc jamais la traduction. */
+  readonly valeur: string;
+  readonly libelle: string;
+  readonly icone?: Icone;
+  readonly ton?: TonDElementDeMenu;
+  readonly desactive?: boolean;
+  /**
+   * L'action est en cours (un export qui se prepare) : leve par l'appelant DES l'activation,
+   * baisse a la reponse. En bouton, l'etat de chargement de `stButton` (indicateur differe,
+   * `aria-busy`, clics avales : aucune seconde activation) ; dans « Plus d'actions », l'entree est
+   * indisponible le temps de l'action, un element de menu n'ayant pas d'indicateur. Comme pour
+   * `stButton`, l'annonce de l'attente revient a l'application (audit UI du 2026-09-27, D-11).
+   */
+  readonly enCours?: boolean;
+}
+/** Taille des boutons secondaires : 44 (defaut, suit la densite), 36 ou 32 px. */
+export type TailleDeBarre = Extract<TailleDeBouton, 'md' | 'sm' | 'xs'>;
+/** Une entree du menu « Plus d'actions » ; `separee` : un separateur la precede (R13). */
+interface EntreeDeBarre {
+  readonly action: ActionDeBarre;
+  readonly separee: boolean;
 }
 /**
- * Barre d'actions d'une page ou d'une section : UNE action principale,
- * projetee, et des actions secondaires qui se replient sous la rupture `md`.
+ * Barre d'actions d'une page ou d'une section : des actions secondaires, decrites, et UNE action
+ * principale, projetee, qui ferme la ligne.
  *
  * ```html
- * <st-toolbar [secondaires]="actions" (action)="agir($event)">
- *   <button stButton variante="primaire" principale (click)="creer()">Nouveau virement</button>
+ * <st-toolbar etiquette="Beneficiaires" [secondaires]="actions" (action)="agir($event)">
+ *   <button stButton variante="primaire" stToolbarPrincipale (click)="creer()">
+ *     Ajouter un beneficiaire
+ *   </button>
  * </st-toolbar>
  * ```
  *
+ * Motif APG « toolbar » (lot 231) : `role="toolbar"` nomme par `etiquette`, UN SEUL arret de
+ * tabulation (indice glissant), Fleches gauche et droite (inversees de droite a gauche), Debut et
+ * Fin. La fleche bas sur « Plus d'actions » ouvre son menu, sur le premier element.
+ *
  * ⚠️ **Pourquoi les secondaires sont des DONNEES** et non des boutons projetes :
- * sous `md`, elles vivent dans un `st-menu` « Plus », dont les elements doivent
+ * sous `md`, elles vivent dans un `st-menu` « Plus d'actions », dont les elements doivent
  * etre ecrits sous l'element qui porte le menu — un contenu projete garde
  * l'injecteur de l'endroit ou il est ecrit, et ne s'y enregistrerait pas. La
- * barre rend donc les deux formes elle-meme, boutons et elements de menu, et
- * n'en montre qu'une a la fois : l'autre est hors de l'arbre d'accessibilite.
- * Elle emet la `valeur` de l'action activee, quelle que soit la forme.
+ * barre rend donc la forme de la rupture, boutons ou elements de menu, jamais les deux : une
+ * action n'existe qu'une fois dans l'arbre d'accessibilite. Elle emet la `valeur` de l'action
+ * activee, quelle que soit la forme.
  *
- * ⚠️ **Une seule action principale.** Deux boutons pleins cote a cote ne disent
- * plus lequel est attendu ; en developpement, la barre le signale. L'action
- * principale est projetee, et non decrite : elle est souvent un `type="submit"`
- * relie a un formulaire, ce qu'une donnee ne saurait dire.
+ * ⚠️ **Un seul bouton plein par barre.** Quand une principale est projetee, une action
+ * `ton: 'danger'` n'est jamais un bouton plein a cote d'elle : elle vit dans « Plus d'actions »,
+ * derniere, apres un separateur. Sans principale (barre d'une selection), elle est rendue en
+ * bouton `danger`. En developpement, la barre signale deux pleins (primaire ou danger) et un
+ * bouton projete sans `principale`, qui ne serait pas rendu.
  *
  * Elle vit dans `ui/surfaces` parce qu'elle importe `st-menu`, donc le CDK :
  * c'est la meme raison qui en a fait sortir `st-header`.
  */
-declare class StToolbar {
-    private readonly libelles;
-    readonly secondaires: _angular_core.InputSignal<readonly ActionDeBarre[]>;
-    /** Texte du declencheur replie. `null` : « Plus », du dictionnaire. */
-    readonly libellePlus: _angular_core.InputSignal<string | null>;
-    /** Emise avec la `valeur` de l'action secondaire activee. */
-    readonly action: _angular_core.OutputEmitterRef<string>;
-    protected readonly libellePlusLu: _angular_core.Signal<string>;
-    protected readonly etiquetteDuMenu: _angular_core.Signal<string>;
-    private readonly boutonsProjetes;
-    constructor();
-    protected declencher(action: ActionDeBarre): void;
-    protected surSelection(valeur: unknown): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StToolbar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StToolbar, "st-toolbar", never, { "secondaires": { "alias": "secondaires"; "required": false; "isSignal": true; }; "libellePlus": { "alias": "libellePlus"; "required": false; "isSignal": true; }; }, { "action": "action"; }, ["boutonsProjetes"], ["[principale]"], true, never>;
-}
-
+export declare class StToolbar {
+  private readonly libelles;
+  private readonly hote;
+  /** Nom de la barre pour les technologies d'assistance (« Actions des beneficiaires »). */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  readonly secondaires: import("@angular/core").InputSignal<readonly ActionDeBarre[]>;
+  /** Nom du bouton « Plus d'actions ». `null` : celui du dictionnaire. */
+  readonly libellePlus: import("@angular/core").InputSignal<string | null>;
+  /** Taille des boutons secondaires : 44 px par defaut, 36 ou 32 (barres des planches 13 et 14). */
+  readonly taille: import("@angular/core").InputSignal<TailleDeBarre>;
+  /** Emise avec la `valeur` de l'action secondaire activee. */
+  readonly action: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly libellePlusLu: import("@angular/core").Signal<string>;
+  /** Forme large (boutons) a partir de la rupture `md`, etroite (menu) en dessous. */
+  private readonly large;
+  /** Le menu « Plus d'actions », s'il est rendu (forme etroite ou danger seul en forme large). */
+  private readonly menuPlus;
+  private readonly boutonsProjetes;
+  private readonly elementsProjetes;
+  private readonly marques;
+  private readonly aPrincipale;
+  /** Les secondaires en boutons (forme large) ; la regle du plein unique en retire le danger. */
+  protected readonly boutons: import("@angular/core").Signal<readonly ActionDeBarre[]>;
+  /** Les entrees du menu : tout en forme etroite, le danger seul en forme large a principale. */
+  protected readonly entrees: import("@angular/core").Signal<readonly EntreeDeBarre[]>;
+  /** L'arret de tabulation unique de la barre. */
+  private actif;
+  constructor();
+  protected varianteDe(action: ActionDeBarre): VarianteDeBouton;
+  protected declencher(action: ActionDeBarre): void;
+  protected surSelection(valeur: unknown): void;
+  protected auFocus(evenement: FocusEvent): void;
+  protected auClavier(evenement: KeyboardEvent): void;
+  /**
+   * Le sens d'ecriture HERITE, comme `st-calendar`, sans style calcule ni mise en page : `:dir()`
+   * resout `dir="auto"`. L'attribut `dir` le plus proche, lu tel quel, prenait « auto » pour de
+   * gauche a droite, et les fleches restaient a l'endroit sous un ancetre de droite a gauche (audit
+   * UI du 2026-09-27, D-6). Il ne sert plus qu'au moteur qui ne connait pas `:dir()`.
+   */
+  private ecritDeDroiteAGauche;
+  /** Les elements de la ligne, dans l'ordre du document ; le menu ferme n'en fait pas partie. */
+  private arrets;
+  /**
+   * Le menu ouvert dont le focus est tombe sur le corps du document (son element focalise a
+   * disparu du DOM au dernier rendu) ferme sans esperer le reprendre : la personne l'a de toute
+   * facon deja perdu.
+   */
+  private fermerLeMenuSiOrphelin;
+  private glisser;
+  private avertir;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StToolbar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StToolbar, "st-toolbar", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "secondaires": {
+      "alias": "secondaires";
+      "required": false;
+      "isSignal": true;
+    };
+    "libellePlus": {
+      "alias": "libellePlus";
+      "required": false;
+      "isSignal": true;
+    };
+    "taille": {
+      "alias": "taille";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "action": "action";
+  }, ["boutonsProjetes", "elementsProjetes", "marques"], ["[principale], [stToolbarPrincipale]"], true, never>;
+}
+/**
+ * Marque l'action PRINCIPALE projetee dans `st-toolbar` : elle ferme la ligne, apres les
+ * secondaires et le « Plus d'actions ». L'attribut nu `principale` reste lu ; la directive le dit
+ * au type, et a l'editeur. La projection se decide sur l'attribut ECRIT dans le gabarit (l'un ou
+ * l'autre), jamais sur un attribut pose par une directive.
+ *
+ * ```html
+ * <st-toolbar etiquette="Beneficiaires" [secondaires]="actions">
+ *   <button stButton variante="primaire" stToolbarPrincipale>Ajouter un beneficiaire</button>
+ * </st-toolbar>
+ * ```
+ */
+export declare class StToolbarPrincipale {
+  static ɵfac: i0.ɵɵFactoryDeclaration<StToolbarPrincipale, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StToolbarPrincipale, "[stToolbarPrincipale]", never, {}, {}, never, never, true, never>;
+}
 /**
  * Identifiant du titre du dialogue, decide a l'ouverture et fourni au contenu.
  *
- * ⚠️ Il est engendre par le service et non par le composant de titre : c'est la
- * configuration du dialogue qui doit porter `aria-labelledby`, et elle est
- * figee a l'ouverture. Un identifiant decide plus tard arriverait apres que le
- * conteneur a lu sa configuration, et le dialogue s'ouvrirait sans nom.
+ * Le CDK (22) fournit l'injecteur du dialogue au composant ouvert COMME au gabarit
+ * (`_attachDialogContent` construit le `TemplatePortal` avec cet injecteur) : un `st-dialog-title`
+ * y recoit donc cet identifiant dans les deux cas, et n'en forge un que hors d'un dialogue ouvert
+ * par `StDialog` (vitrine).
+ *
+ * Depuis le lot 229, le NOM du dialogue ne depend pas de ce jeton : le conteneur lit l'identifiant
+ * du titre REELLEMENT rendu dans son DOM, et ne pose `aria-labelledby` que s'il existe. Un dialogue
+ * sans titre ne porte donc plus de `aria-labelledby` pendant (A1204).
  */
-declare const IDENTIFIANT_DU_TITRE: InjectionToken<string>;
-
+export declare const IDENTIFIANT_DU_TITRE: InjectionToken<string>;
+/** Ce qu'un dialogue ouvert par `StDialog` dit a son contenu. */
+export interface ContexteDeDialogue {
+  /**
+   * La croix standard de `st-dialog-title` est-elle offerte ? Faux pour un `alertdialog`, qui
+   * exige une REPONSE, et sous `fermetureInterdite`, ou seules les actions ferment (ADR 0005
+   * D54). Ne gouverne QUE cette croix : une action `[stDialogClose]` reste toujours visible.
+   */
+  readonly fermable: boolean;
+}
+/**
+ * Contexte du dialogue, fourni par `StDialog` a chaque ouverture. Absent hors d'un dialogue (une
+ * vitrine de galerie) : la croix de `st-dialog-title` n'y apparait que si on la demande.
+ */
+export declare const CONTEXTE_DE_DIALOGUE: InjectionToken<ContexteDeDialogue>;
+/** Ton d'une confirmation : `danger` pour ce qui detruit, `primaire` sinon. */
+export type TonDeConfirmation = Extract<TonSemantique, 'primaire' | 'danger'>;
 /**
  * Ce que l'appelant decrit pour obtenir une confirmation.
  *
@@ -179,124 +674,233 @@ declare const IDENTIFIANT_DU_TITRE: InjectionToken<string>;
  * changement d'IBAN — merite une re-authentification par second facteur, que le
  * backend sait deja demander.
  */
-interface DemandeDeConfirmation {
-    readonly titre: string;
-    readonly message: string;
-    readonly libelleConfirmation?: string;
-    readonly libelleAnnulation?: string;
-    /** L'action detruit quelque chose : le bouton passe en `danger`. */
-    readonly destructeur?: boolean;
-    /**
-     * Texte que la personne doit recopier pour confirmer.
-     *
-     * ⚠️ A reserver a l'irreversible. Ce n'est pas une ceinture de securite de
-     * plus : c'est le seul moyen de rompre l'automatisme de qui clique « Oui »
-     * sans lire, et son cout — une saisie — n'est justifie que la ou l'erreur ne
-     * se repare pas.
-     */
-    readonly saisieDeConfirmation?: string;
-}
-/**
- * Dialogue de confirmation.
+export interface DemandeDeConfirmation {
+  /** Une question fermee : « Revoquer cet appareil ? ». */
+  readonly titre: string;
+  /**
+   * Ce qui sera perdu, en une ou deux phrases. C'est la DESCRIPTION du dialogue : le lecteur
+   * d'ecran la lit apres le titre, avant les boutons. La valeur a recopier y est mise en valeur
+   * la ou le message la nomme (guillemets compris).
+   */
+  readonly message: string;
+  /** Repete le verbe de l'action (« Supprimer », « Revoquer ») ; defaut « Confirmer ». */
+  readonly libelleConfirmation?: string;
+  readonly libelleAnnulation?: string;
+  /**
+   * `danger` : l'action detruit quelque chose. Bouton `danger`, icone d'intention
+   * `triangle-alerte` et surtitre dans la couleur du danger, fond inerte. Defaut : `primaire`.
+   */
+  readonly ton?: TonDeConfirmation;
+  /** Icone du titre. Defaut : `triangle-alerte` sous `danger`, aucune sinon ; `null` la retire. */
+  readonly icone?: NomDIcone | null;
+  /** Surtitre sous le titre (reference, portee), en capitales dans la couleur du ton. */
+  readonly sousTitre?: string;
+  /** Icone du bouton de confirmation (`corbeille-croix` pour une suppression). */
+  readonly iconeConfirmation?: NomDIcone;
+  /**
+   * Croix standard dans l'en-tete : elle vaut « Annuler ». Defaut : vrai.
+   *
+   * ⚠️ Sans effet sous `ton: 'danger'` OU avec `saisieDeConfirmation` : la
+   * confirmation est alors un `alertdialog`, qui n'a jamais de croix (ADR 0005 D54 et D68) ; Echap y
+   * vaut « Annuler », jamais la confirmation.
+   */
+  readonly fermable?: boolean;
+  /**
+   * Texte que la personne doit recopier pour confirmer. Le dialogue devient un `alertdialog`,
+   * sans croix (D54) : « Annuler » et Echap sont ses seules sorties sans confirmation.
+   *
+   * ⚠️ A reserver a l'irreversible. Ce n'est pas une ceinture de securite de
+   * plus : c'est le seul moyen de rompre l'automatisme de qui clique « Oui »
+   * sans lire, et son cout — une saisie — n'est justifie que la ou l'erreur ne
+   * se repare pas. Un nom court, jamais un IBAN complet (SEC-3).
+   */
+  readonly saisieDeConfirmation?: string;
+}
+/** Un morceau de texte : la valeur mise en valeur, ou ce qui l'entoure. */
+interface Morceau {
+  readonly texte: string;
+  readonly valeur: boolean;
+}
+/**
+ * Dialogue de confirmation, ouvert par `StDialog.confirmer(demande)` (planche 5, dialogue A).
  *
  * ⚠️ **Le bouton de confirmation n'est jamais celui qui recoit le focus.** Le
- * dialogue entier le recoit (voir `StDialog`), et le premier arret de
- * tabulation est l'annulation. Un dialogue destructeur dont le bouton dangereux
- * est deja focalise se valide par une seule touche Entree — c'est-a-dire par le
- * geste que la personne etait en train de faire quand il s'est ouvert.
- */
-declare class StConfirmDialog {
-    private readonly reference;
-    private readonly libelles;
-    protected readonly demande: DemandeDeConfirmation;
-    protected readonly saisie: _angular_core.WritableSignal<string>;
-    /** Unique par instance : deux confirmations empilees dupliqueraient un identifiant fixe. */
-    protected readonly identifiantDeSaisie: string;
-    protected readonly ton: _angular_core.Signal<TonSemantique>;
-    protected readonly libelleConfirmation: _angular_core.Signal<string>;
-    protected readonly libelleAnnulation: _angular_core.Signal<string>;
-    protected readonly libelleRecopie: _angular_core.Signal<string>;
-    /**
-     * ⚠️ La comparaison ignore la casse et les espaces de bord, mais RIEN
-     * d'autre. Exiger la casse exacte transforme une confirmation en jeu
-     * d'adresse, et pousse a copier-coller — ce qui annule precisement l'effet
-     * recherche.
-     */
-    protected readonly confirmationPossible: _angular_core.Signal<boolean>;
-    protected auChangement(evenement: Event): void;
-    protected confirmer(): void;
-    protected annuler(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StConfirmDialog, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StConfirmDialog, "st-confirm-dialog", never, {}, {}, never, never, true, never>;
-}
-
+ * dialogue entier le recoit (voir `StDialog`), et le premier arret de tabulation est la croix
+ * (quand elle est rendue : jamais sur un `alertdialog`, D54), puis le champ de recopie s'il
+ * existe, puis l'annulation. Un dialogue
+ * destructeur dont le bouton dangereux est deja focalise se valide par une seule touche Entree —
+ * c'est-a-dire par le geste que la personne etait en train de faire quand il s'est ouvert.
+ *
+ * ⚠️ **La recopie parle.** Entree dans le champ confirme si la recopie correspond ; sinon le
+ * champ passe `aria-invalid`, un message d'erreur relie apparait sous lui, une region d'alerte
+ * l'annonce (le champ garde le focus : rien n'est relu sans ca), et le focus y reste. Le bouton
+ * indisponible dit pourquoi (`raisonIndisponible`) : jamais un bouton muet.
+ */
+export declare class StConfirmDialog {
+  /** La valeur mise en valeur s'affiche comme elle se recopie : sur une ligne, sans invisible. */
+  protected readonly uneLigne: typeof texteDUneLigne;
+  private readonly reference;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly identifiants;
+  protected readonly demande: DemandeDeConfirmation;
+  protected readonly saisie: import("@angular/core").WritableSignal<string>;
+  /** Une validation a ete tentee (Entree dans le champ) : l'erreur peut se montrer. */
+  private readonly tentative;
+  /**
+   * Annonce l'echec d'une recopie a chaque tentative (alerte assertive) : le message d'erreur
+   * n'a ni role ni region vivante (`st-inline-message` sans `annonce`, reserve a un message qui
+   * apparait APRES un formulaire), et le focus reste dans le champ deja focalise — ni l'un ni
+   * l'autre changement n'est donc relu par NVDA ou JAWS sans cette region dediee. `AnnonceLocale`
+   * vide puis remplit, ce qui fait relire une seconde tentative identique.
+   */
+  protected readonly erreurAnnoncee: AnnonceLocale;
+  /**
+   * Identifiant du message, que `StDialog.confirmer` relie par `aria-describedby` : il le passe
+   * dans les donnees (champ interne) ; un dialogue ouvert autrement en forge un.
+   */
+  protected readonly identifiantDuMessage: string;
+  /** Uniques par instance : deux confirmations empilees dupliqueraient un identifiant fixe. */
+  protected readonly identifiantDeSaisie: string;
+  protected readonly identifiantDeLAide: string;
+  protected readonly identifiantDeLErreur: string;
+  protected readonly ton: import("@angular/core").Signal<TonDeConfirmation>;
+  /** Ton de l'en-tete : `danger` le met en forme « ton » ; sinon un titre simple ou a tuile. */
+  protected readonly tonDuTitre: import("@angular/core").Signal<TonSemantique>;
+  protected readonly icone: import("@angular/core").Signal<"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" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "devise" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier" | "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" | "iban" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu" | "menu-ouvert" | "message" | "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>;
+  protected readonly libelleConfirmation: import("@angular/core").Signal<string>;
+  protected readonly libelleAnnulation: import("@angular/core").Signal<string>;
+  protected readonly libelleRecopie: import("@angular/core").Signal<string>;
+  /** Le message, la valeur a recopier mise en valeur la ou il la nomme. */
+  protected readonly morceauxDuMessage: import("@angular/core").Signal<readonly Morceau[]>;
+  /** L'etiquette du champ, la valeur a recopier dans sa propre boite (chasse fixe). */
+  protected readonly morceauxDeLEtiquette: import("@angular/core").Signal<readonly Morceau[]>;
+  /**
+   * ⚠️ La comparaison ignore la casse et les espaces de bord, mais RIEN
+   * d'autre. Exiger la casse exacte transforme une confirmation en jeu
+   * d'adresse, et pousse a copier-coller — ce qui annule precisement l'effet
+   * recherche. L'aide sous le champ le dit.
+   *
+   * ⚠️ Normalisee en NFC puis comparee avec `toLowerCase()` (jamais `toLocaleLowerCase()` sans
+   * argument) : une valeur composee en NFD (claviers macOS, certains IME) doit correspondre a la
+   * meme valeur affichee en NFC, et le repli sur la locale par defaut du NAVIGATEUR ferait echouer
+   * une recopie exacte sous une locale a regle de casse particuliere (le i turc, par exemple).
+   */
+  protected readonly confirmationPossible: import("@angular/core").Signal<boolean>;
+  /** La recopie correspond : la coche de succes s'affiche dans le champ. */
+  protected readonly correspond: import("@angular/core").Signal<boolean>;
+  /** Erreur montree apres une tentative, tant que la recopie ne correspond pas. */
+  protected readonly invalide: import("@angular/core").Signal<boolean>;
+  protected readonly descriptionDuChamp: import("@angular/core").Signal<string>;
+  protected auChangement(evenement: Event): void;
+  /** Entree dans le champ : confirme si la recopie correspond, sinon le dit et garde le focus. */
+  protected valider(evenement: Event): void;
+  protected confirmer(): void;
+  protected annuler(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StConfirmDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StConfirmDialog, "st-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
 /** Ce que l'appelant regle a l'ouverture. */
-interface OptionsDeDialogue<D = unknown> {
-    /** Donnees passees au composant, lisibles par `DONNEES_DE_DIALOGUE`. */
-    readonly donnees?: D;
-    /**
-     * Nom accessible quand le dialogue n'affiche pas de `st-dialog-title`.
-     * Inutile — et ignore — des qu'un titre est present.
-     */
-    readonly etiquette?: string;
-    /**
-     * Interdit Echap et le clic sur le fond.
-     *
-     * ⚠️ A reserver aux dialogues qui perdraient du travail en se fermant. Un
-     * dialogue qu'on ne peut pas fermer au clavier est une impasse pour qui
-     * n'utilise pas la souris ; la fermeture doit alors exister ailleurs, en
-     * toutes lettres.
-     */
-    readonly fermetureInterdite?: boolean;
-    /**
-     * Ignore le clic sur le fond, mais laisse Echap fermer.
-     *
-     * ⚠️ La distinction compte, et le CDK ne la fait pas : son `disableClose`
-     * bloque les DEUX. Or le clic hors du panneau est le geste le plus facile a
-     * faire par megarde, tandis qu'Echap est un choix delibere — et, sur une
-     * confirmation, il vaut ANNULER, ce qui est sans danger. Bloquer Echap ne
-     * protege rien et prive le clavier de sa sortie.
-     */
-    readonly fondInerte?: boolean;
-    /**
-     * `alertdialog` pour ce qui exige une reponse immediate : une session qui
-     * expire, une perte imminente. Le lecteur d'ecran l'annonce avec plus
-     * d'insistance qu'un dialogue ordinaire — a ne pas galvauder.
-     */
-    readonly role?: 'dialog' | 'alertdialog';
-    /**
-     * Selecteur de l'element qui recoit le focus a l'ouverture, a la place du
-     * dialogue lui-meme.
-     *
-     * ⚠️ Pour un `alertdialog`, le motif ARIA veut le focus sur l'action la MOINS
-     * destructrice : « Rester connecte », jamais « Se deconnecter ». Une touche
-     * Entree reflexe ne doit rien detruire.
-     */
-    readonly focusInitial?: string;
-    /** Identifiant du texte qui DECRIT le dialogue, lu a l'ouverture apres son nom. */
-    readonly descriptionDe?: string;
-    readonly largeur?: string;
-    readonly classe?: string;
-    /**
-     * Ancre le panneau sur un bord : c'est le TIROIR.
-     *
-     * ⚠️ Un tiroir modal EST un dialogue — meme role, meme piegeage du focus,
-     * meme Echap. Seule sa geometrie change. Lui donner son propre service
-     * dupliquerait toute la machinerie d'accessibilite pour une difference de
-     * position, et la copie finirait par deriver de l'original.
-     *
-     * `debut` et `fin` suivent le sens d'ecriture ; `bas` donne la feuille
-     * inferieure, qui est la forme utile sur telephone.
-     */
-    readonly cote?: CoteDuTiroir;
+export interface OptionsDeDialogue<D = unknown> {
+  /** Donnees passees au composant, lisibles par `DONNEES_DE_DIALOGUE`. */
+  readonly donnees?: D;
+  /**
+   * Nom accessible quand le dialogue n'affiche pas de `st-dialog-title`, ou tant que son titre
+   * n'a pas de texte (titre differe ou lie a des donnees en chargement). Des qu'un titre au texte
+   * non vide est rendu, le titre visible l'emporte.
+   */
+  readonly etiquette?: string;
+  /**
+   * Retire la croix, Echap, le clic sur le fond ET la fermeture par navigation (routeur comme
+   * historique) : seules les actions du dialogue le ferment (ADR 0005 D54).
+   *
+   * ⚠️ A reserver aux dialogues qui perdraient du travail en se fermant. Un
+   * dialogue qu'on ne peut pas fermer au clavier est une impasse pour qui
+   * n'utilise pas la souris ; la fermeture doit alors exister ailleurs, en
+   * toutes lettres : une action `[stDialogClose]`, toujours visible.
+   */
+  readonly fermetureInterdite?: boolean;
+  /**
+   * Ignore le clic sur le fond, mais laisse Echap fermer.
+   *
+   * ⚠️ La distinction compte, et le CDK ne la fait pas : son `disableClose`
+   * bloque les DEUX. Or le clic hors du panneau est le geste le plus facile a
+   * faire par megarde, tandis qu'Echap est un choix delibere — et, sur une
+   * confirmation, il vaut ANNULER, ce qui est sans danger. Bloquer Echap ne
+   * protege rien et prive le clavier de sa sortie.
+   */
+  readonly fondInerte?: boolean;
+  /**
+   * `alertdialog` pour ce qui exige une reponse immediate : une session qui
+   * expire, une perte imminente. Le lecteur d'ecran l'annonce avec plus
+   * d'insistance qu'un dialogue ordinaire — a ne pas galvauder.
+   */
+  readonly role?: 'dialog' | 'alertdialog';
+  /**
+   * Offre la croix standard de `st-dialog-title`. Defaut : vrai. Ne gouverne QUE cette croix :
+   * une action `[stDialogClose]` reste toujours visible (ADR 0005 D54).
+   *
+   * ⚠️ Sans effet sur un `alertdialog` ni sous `fermetureInterdite`, qui n'ont JAMAIS de croix
+   * (D54) : le premier exige une reponse, et Echap y rend l'issue non destructive ; le second ne
+   * se ferme que par ses actions. `fermable: true` y est ignore (avertissement en developpement).
+   * Faux : le dialogue se ferme par ses actions (et Echap).
+   */
+  readonly fermable?: boolean;
+  /**
+   * Largeur d'un dialogue centre, par les jetons (D2) : `sm` 24rem (confirmation), `md` 32rem
+   * (defaut, formulaire court), `lg` 48rem (tableau, comparaison). Sous 480 px, toutes prennent
+   * `100vw - 32 px`. Sans effet sur un tiroir ; `largeur` reste la derogation libre.
+   */
+  readonly taille?: TailleDeDialogue;
+  /**
+   * Garde le dialogue ouvert a une navigation, du routeur comme de l'historique. Defaut : vrai
+   * pour un `alertdialog`, faux sinon.
+   *
+   * ⚠️ Un `alertdialog` exige une REPONSE. Le fermer a une navigation le resolvait sans resultat,
+   * et l'avertissement d'inactivite prenait ce silence pour « Rester connecte » : une redirection
+   * programmee prolongeait la session sans personne devant l'ecran (A1199, A1216).
+   */
+  readonly survitALaNavigation?: boolean;
+  /**
+   * Selecteur de l'element qui recoit le focus a l'ouverture, a la place du
+   * dialogue lui-meme.
+   *
+   * ⚠️ Pour un `alertdialog`, le motif ARIA veut le focus sur l'action la MOINS
+   * destructrice : « Rester connecte », jamais « Se deconnecter ». Une touche
+   * Entree reflexe ne doit rien detruire.
+   */
+  readonly focusInitial?: string;
+  /** Identifiant du texte qui DECRIT le dialogue, lu a l'ouverture apres son nom. */
+  readonly descriptionDe?: string;
+  /**
+   * Largeur imposee du panneau. Absente : celle de la feuille des couches
+   * (`@starterlib/ui/styles/couches.css`) — celle de `taille` pour un dialogue (32rem par
+   * defaut), 28rem pour un tiroir lateral, toute la largeur pour une feuille inferieure, sans
+   * jamais depasser l'ecran. Honoree dans les trois cas (A1214).
+   */
+  readonly largeur?: string;
+  readonly classe?: string;
+  /**
+   * Ancre le panneau sur un bord : c'est le TIROIR.
+   *
+   * ⚠️ Un tiroir modal EST un dialogue — meme role, meme piegeage du focus,
+   * meme Echap. Seule sa geometrie change. Lui donner son propre service
+   * dupliquerait toute la machinerie d'accessibilite pour une difference de
+   * position, et la copie finirait par deriver de l'original.
+   *
+   * `debut` et `fin` suivent le sens d'ecriture ; `bas` donne la feuille
+   * inferieure, qui est la forme utile sur telephone.
+   */
+  readonly cote?: CoteDuTiroir;
 }
+/** Largeur d'un dialogue centre (jetons `--st-largeur-dialogue-*`). */
+export type TailleDeDialogue = 'sm' | 'md' | 'lg';
 /** Bord auquel un tiroir s'ancre. Logique, donc juste aussi en ecriture droite a gauche. */
-type CoteDuTiroir = 'debut' | 'fin' | 'bas';
+export type CoteDuTiroir = 'debut' | 'fin' | 'bas';
 /** Reference sur un dialogue ouvert. */
-interface ReferenceDeDialogue<R> {
-    /** Resout a la fermeture. `undefined` quand le dialogue est simplement quitte. */
-    readonly ferme: Promise<R | undefined>;
-    fermer(resultat?: R): void;
+export interface ReferenceDeDialogue<R> {
+  /** Resout a la fermeture. `undefined` quand le dialogue est simplement quitte. */
+  readonly ferme: Promise<R | undefined>;
+  fermer(resultat?: R): void;
 }
 /**
  * Ouvre des dialogues modaux.
@@ -308,45 +912,68 @@ interface ReferenceDeDialogue<R> {
  * Le socle n'en reecrit aucune part.
  *
  * Ce qu'il ajoute au CDK : le focus sur le dialogue, `aria-modal`, un fond inerte
- * qui laisse Echap fermer, et la fermeture a toute navigation du routeur.
- */
-declare class StDialog {
-    private readonly cdk;
-    private readonly overlay;
-    /** Une fonction de fermeture par dialogue ouvert : c'est tout ce qu'il faut garder. */
-    private readonly ouverts;
-    constructor();
-    /**
-     * Ouvre un composant, ou un GABARIT.
-     *
-     * Un gabarit sert quand le contenu vit deja dans le composant appelant — un
-     * tiroir de navigation qui deplace ses propres liens sur petit ecran. ⚠️ Son
-     * injecteur reste celui de l'endroit ou il est ECRIT : un `st-dialog-title`
-     * pose dedans ne recoit pas l'identifiant de titre, et le dialogue se nomme
-     * alors par `etiquette`.
-     */
-    ouvrir<R = unknown, D = unknown>(composant: Type<unknown> | TemplateRef<unknown>, options?: OptionsDeDialogue<D>): ReferenceDeDialogue<R>;
-    /**
-     * ⚠️ Un tiroir occupe toute la hauteur du bord ou il s'ancre, et une feuille
-     * inferieure toute la largeur. Sans cela, le panneau flotte au milieu et ne
-     * se lit plus comme un tiroir.
-     */
-    private geometrie;
-    private classes;
-    /**
-     * Demande une confirmation, et rend `true` seulement si elle est donnee.
-     *
-     * ⚠️ La fermeture par Echap ou par le fond rend `false` : quitter n'est pas
-     * confirmer. C'est pourquoi la valeur est comparee explicitement plutot que
-     * testee pour sa veracite — `undefined` doit valoir non.
-     */
-    confirmer(demande: DemandeDeConfirmation): Promise<boolean>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDialog, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
-}
-
-/**
- * Le panneau du dialogue : sa surface, son arrondi, son ombre.
+ * qui laisse Echap fermer, la croix standard (`fermable`), et la fermeture a toute navigation
+ * ABOUTIE du routeur — sauf pour un `alertdialog`, qui attend sa reponse
+ * (`survitALaNavigation`), et un dialogue `fermetureInterdite`.
+ *
+ * Mouvement (03 §3.5, lot 196) : le voile (`st-voile`, feuille des couches) et le
+ * panneau arrivent en fondu, le panneau monte de `--st-deplacement-moyen` ; un
+ * tiroir glisse depuis son bord. A la fermeture, panneau et voile partent
+ * ENSEMBLE en fondu, et la couche n'est detachee qu'a la fin de la transition —
+ * ou dans la meme tache quand la duree vaut zero (mouvement reduit, gel). Une
+ * fermeture par NAVIGATION est immediate : la page change dessous, un fondu la
+ * retarderait.
+ *
+ * ⚠️ Le focus revient au declencheur au DETACHEMENT, et non a la demande : tant que
+ * la couche est la, le CDK garde le reste de la page en `aria-hidden`, et un focus
+ * pose dans une region masquee n'est pas annonce. L'attente est bornee par la
+ * duree de sortie (120 ms), nulle sous mouvement reduit.
+ */
+export declare class StDialog {
+  private readonly cdk;
+  private readonly overlay;
+  /** Identifiants prefixes par l'APP_ID (lot 228) : deux applications dans la page n'ont plus le meme titre. */
+  private readonly identifiants;
+  /** Une fonction de fermeture par dialogue ouvert : c'est tout ce qu'il faut garder. */
+  private readonly ouverts;
+  constructor();
+  /**
+   * Ouvre un composant, ou un GABARIT.
+   *
+   * Un gabarit sert quand le contenu vit deja dans le composant appelant — un
+   * tiroir de navigation qui deplace ses propres liens sur petit ecran. Un
+   * `st-dialog-title` pose dedans le nomme (le conteneur lit son identifiant dans le DOM) ;
+   * sans titre, `etiquette` est OBLIGATOIRE : un dialogue encore sans nom une fois l'application
+   * stable est signale en developpement (`console.error`).
+   *
+   * ⚠️ Un titre DIFFERE (donnees chargees, `@defer`) ou encore vide exige aussi `etiquette` : le
+   * lecteur d'ecran annonce le nom au focus d'ouverture et ne le relit pas. `etiquette` nomme le
+   * dialogue a cet instant, puis le titre la remplace des qu'il porte un texte ; sans elle, un nom
+   * arrive apres le focus est averti en developpement (`console.warn`).
+   */
+  ouvrir<R = unknown, D = unknown>(composant: Type<unknown> | TemplateRef<unknown>, options?: OptionsDeDialogue<D>): ReferenceDeDialogue<R>;
+  /**
+   * ⚠️ Un tiroir occupe toute la hauteur du bord ou il s'ancre, et une feuille
+   * inferieure toute la largeur. Sans cela, le panneau flotte au milieu et ne
+   * se lit plus comme un tiroir.
+   */
+  private geometrie;
+  private classes;
+  /**
+   * Demande une confirmation, et rend `true` seulement si elle est donnee.
+   *
+   * ⚠️ La fermeture par Echap ou par le fond rend `false` : quitter n'est pas
+   * confirmer. C'est pourquoi la valeur est comparee explicitement plutot que
+   * testee pour sa veracite — `undefined` doit valoir non.
+   */
+  confirmer(demande: DemandeDeConfirmation): Promise<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDialog, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Forme du panneau : dialogue centre, tiroir lateral, feuille inferieure. */
+export type FormeDuPanneauDeDialogue = 'dialogue' | 'tiroir' | 'feuille';
+/**
+ * Le panneau du dialogue : sa surface, son filet, son arrondi, son ombre.
  *
  * ⚠️ Pourquoi ce composant existe. `CdkDialogContainer` n'a **aucune
  * apparence** : c'est voulu de la part du CDK, qui ne decide d'aucun style. Le
@@ -360,29 +987,141 @@ declare class StDialog {
  * l'oubli ne se verrait qu'a l'ecran. Ici, l'apparence voyage avec le
  * composant.
  *
+ * Nom accessible (lot 229, A1204 et revue) : `aria-labelledby` vise le titre REELLEMENT rendu
+ * dans le panneau (`st-dialog-title`), jamais un identifiant pendant ; sans titre, `aria-label`
+ * porte `etiquette`. Le titre l'emporte, comme `OptionsDeDialogue.etiquette` le dit. Les
+ * attributs viennent de la `DialogConfig` PUBLIQUE injectee, plus du `_config` interne du CDK.
+ *
+ * ⚠️ Le nom est ECRIT sur l'hote dans la phase `write` de chaque rendu, et non par une liaison
+ * d'hote nourrie d'un signal : le CDK pose le focus d'ouverture dans un `afterNextRender` de phase
+ * `mixedReadWrite`, qui suit `write` et precede `read` dans le MEME rendu. Lu en `read` puis lie,
+ * le nom n'arrivait qu'au rendu suivant, le focus deja pose : le lecteur d'ecran annoncait
+ * « dialogue », sans nom, et ne le relisait pas.
+ *
+ * Le titre ne nomme que s'il porte un TEXTE : un titre lie a des donnees encore absentes rendrait
+ * un nom vide au focus d'ouverture ; `etiquette` nomme alors le dialogue jusqu'a l'arrivee du
+ * texte (revue 2 du lot 229).
+ *
+ * Controles de developpement, une fois l'application stable (titre differe par `@defer`, une
+ * requete ou une macro-tache compris) : un dialogue au nom encore vide est signale
+ * (`console.error`) ; un nom arrive APRES le focus d'ouverture est averti (`console.warn` : le
+ * lecteur d'ecran a annonce « dialogue » sans nom et ne relit pas ; poser `etiquette`) ; un
+ * dialogue au fond inerte (`fermetureInterdite`, `fondInerte`) sans aucune sortie visible (ni
+ * `[stDialogClose]`, croix comprise, ni bouton dans `st-dialog-actions`) est signale
+ * (`console.error`) : c'est une impasse (WCAG 2.1.2).
+ *
  * L'encapsulation reste EMULEE : seuls l'hote et le panneau qui l'enveloppe
  * sont styles, par `:host` et `:host-context()`. Aucun contenu projete n'est
  * vise, donc rien ne justifie de rendre ces styles globaux.
  */
-declare class StDialogContainer extends CdkDialogContainer {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDialogContainer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDialogContainer, "st-dialog-container", never, {}, {}, never, never, true, never>;
+export declare class StDialogContainer extends CdkDialogContainer {
+  protected readonly configuration: DialogConfig<unknown, unknown, import("@angular/cdk/dialog").DialogContainer>;
+  protected readonly forme: FormeDuPanneauDeDialogue;
+  constructor();
+  /**
+   * Controles de developpement, APRES stabilisation : un titre differe (donnees chargees, `@defer`,
+   * macro-tache) n'est pas un nom absent. Attendre la stabilite, une macro-tache, puis la stabilite
+   * a nouveau couvre ce qui s'enregistre comme tache en attente (requetes, `@defer`, rendus
+   * planifies) et ce qu'une macro-tache immediate declenche. `console.error` et non une exception :
+   * un `ErrorHandler` strict ne doit pas faire d'un nom tardif un echec d'application.
+   *
+   * ⚠️ Chaque attente est COURUE contre la destruction : une tache en attente qui ne finit jamais
+   * (flux SSE, sondage long) laissait `whenStable()` pendant, et la fermeture retenue garder
+   * l'hote detache et tout son contenu (revue 2 du lot 229).
+   */
+  private controlerEnDeveloppement;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDialogContainer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDialogContainer, "st-dialog-container", never, {}, {}, never, never, true, never>;
 }
-
+/** Niveau du titre : 2 par defaut, la page dessous a deja son `h1`. */
+export type NiveauDeTitreDeDialogue = 2 | 3 | 4;
+/**
+ * Forme de l'en-tete, deduite des entrees (planche 5) :
+ * - `simple` : titre seul (et sous-titre discret) ;
+ * - `tuile` : `icone` dans une tuile de 36 px, sous-titre discret, filet PERMANENT sous l'en-tete ;
+ * - `ton` : `ton` autre que `neutre` : icone de ton nue, surtitre en capitales dans la couleur du
+ *   ton, sans filet (dialogue de confirmation).
+ */
+export type FormeDEnteteDeDialogue = 'simple' | 'tuile' | 'ton';
 /**
- * Titre du dialogue. Il porte l'identifiant que la configuration a designe en
- * `aria-labelledby` : c'est lui qui NOMME le dialogue.
+ * En-tete du dialogue : son titre, qui NOMME le dialogue, et la croix standard.
+ *
+ * ```html
+ * <st-dialog-title icone="utilisateur-crayon" sousTitre="Mandat ISO-20022">
+ *   Modifier le beneficiaire
+ * </st-dialog-title>
+ * <st-dialog-title ton="danger" icone="triangle-alerte" sousTitre="Action definitive">
+ *   Revoquer l'acces a ce terminal ?
+ * </st-dialog-title>
+ * ```
+ *
+ * ⚠️ Un `h2` par defaut et non un `h1` : le dialogue s'ouvre par-dessus une page qui a deja son
+ * titre de niveau 1, et deux `h1` cassent la table des matieres des lecteurs d'ecran. `niveau`
+ * le change pour un dialogue pose dans une section plus profonde.
  *
- * ⚠️ Un `h2` et non un `h1` : le dialogue s'ouvre par-dessus une page qui a
- * deja son titre de niveau 1, et deux `h1` cassent la table des matieres que
- * les lecteurs d'ecran construisent.
+ * L'identifiant du titre est celui que `StDialog` fournit (composant comme gabarit : le CDK leur
+ * donne l'injecteur du dialogue), a defaut un identifiant forge ici (vitrine) : le conteneur le lit
+ * dans son DOM pour poser `aria-labelledby` (lot 229, A1204).
+ *
+ * La croix (`fermeture`) : `button[stIconButton][stDialogClose]` de 44 px, glyphe de 20 qui
+ * affleure la marge du texte. Par defaut, elle suit le dialogue : presente s'il est `fermable`,
+ * absente d'un `alertdialog` et d'un dialogue `fermetureInterdite` (ADR 0005 D54), qui ne la
+ * rendent JAMAIS, meme demandee. Hors d'un dialogue (vitrine), elle n'apparait que sur
+ * `[fermeture]="true"`. L'emplacement `[fermeture]` recoit une fermeture propre au lieu de la
+ * croix (poser alors `[fermeture]="false"`).
  */
-declare class StDialogTitle {
-    protected readonly identifiant: string | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDialogTitle, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDialogTitle, "st-dialog-title", never, {}, {}, never, ["*"], true, never>;
+export declare class StDialogTitle {
+  private readonly contexte;
+  private readonly dansUnDialogue;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  protected readonly identifiant: string;
+  /** Icone de l'en-tete : en tuile, ou nue dans la couleur du `ton`. */
+  readonly icone: import("@angular/core").InputSignal<"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" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "devise" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier" | "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" | "iban" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu" | "menu-ouvert" | "message" | "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>;
+  /** Ton de l'en-tete (confirmation, alerte) : icone et surtitre dans sa couleur. */
+  readonly ton: import("@angular/core").InputSignal<TonSemantique>;
+  /** Ligne sous le titre : reference, contexte. En capitales sous un `ton`. */
+  readonly sousTitre: import("@angular/core").InputSignal<string | null>;
+  readonly niveau: import("@angular/core").InputSignal<NiveauDeTitreDeDialogue>;
+  /**
+   * Croix standard ; `undefined` : celle du dialogue (`fermable`), absente hors dialogue. Un
+   * attribut nu (`fermeture`) vaut vrai, comme toute entree booleenne du socle (audit du
+   * 2026-09-27, Q-16).
+   */
+  readonly fermeture: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  protected readonly forme: import("@angular/core").Signal<FormeDEnteteDeDialogue>;
+  /** Sous un `ton` sans icone ecrite, l'icone du ton (table unique du socle). */
+  protected readonly iconeRendue: import("@angular/core").Signal<"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" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "devise" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier" | "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" | "iban" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu" | "menu-ouvert" | "message" | "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>;
+  protected readonly tonDeLIcone: import("@angular/core").Signal<TonSemantique>;
+  protected readonly croix: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDialogTitle, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDialogTitle, "st-dialog-title", never, {
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "sousTitre": {
+      "alias": "sousTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "niveau": {
+      "alias": "niveau";
+      "required": false;
+      "isSignal": true;
+    };
+    "fermeture": {
+      "alias": "fermeture";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*", "[fermeture]"], true, never>;
 }
-
 /**
  * Corps du dialogue, defilant quand il deborde.
  *
@@ -391,70 +1130,149 @@ declare class StDialogTitle {
  * l'ecran est le defaut classique, et il ne se voit qu'a 200 % d'echelle ou sur
  * un ecran bas.
  *
- * ⚠️ **Focalisable seulement quand il defile.** Une zone defilante sans
+ * Sa hauteur DERIVE du panneau (lot 229, A1443) : il prend la place que le titre et les actions
+ * laissent (`flex: 1 1 auto`), le panneau portant la hauteur maximale (dialogue centre :
+ * `100dvh - 48 px` ; tiroir : pleine hauteur). L'ancien plafond de `60vh` laissait un tiroir a
+ * moitie vide sous ses actions.
+ *
+ * ⚠️ **Focalisable et nomme seulement quand il defile.** Une zone defilante sans
  * controle doit recevoir le focus, sinon le clavier ne peut pas la faire
- * defiler — le texte d'une condition generale, par exemple. Mais la premiere
+ * defiler — le texte d'une condition generale, par exemple ; elle devient alors une
+ * `region` nommee, pour que le lecteur d'ecran dise ou le focus s'est pose. Mais la premiere
  * version posait `tabindex="0"` sans condition : sur un dialogue court, la zone
  * de texte devenait le premier arret de tabulation, AVANT le bouton
  * d'annulation, contrairement a ce que `StConfirmDialog` affirmait.
+ *
+ * Rembourrage `md` : 16 / 24 sous un en-tete simple ou de ton, 24 sous un en-tete a filet
+ * permanent (forme `tuile`), comme la planche 5.
+ *
+ * Quand il defile, deux filets capillaires l'encadrent (planche 5) : deux elements a part, hors
+ * de la zone qui defile, comme les sentinelles de la planche. `data-defile-haut` et
+ * `data-defile-bas`, sur l'hote, disent s'il reste du contenu au-dessus ou au-dessous (lisibles
+ * par une feuille d'application). La zone qui defile est `.st-dialog-content__corps`.
  */
-declare class StDialogContent {
-    /** `aucun` pour un contenu qui gere ses propres marges, comme un tableau. */
-    readonly rembourrage: _angular_core.InputSignal<"aucun" | "md">;
-    protected readonly defilante: _angular_core.WritableSignal<boolean>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDialogContent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDialogContent, "st-dialog-content", never, { "rembourrage": { "alias": "rembourrage"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+export declare class StDialogContent {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  /** `aucun` pour un contenu qui gere ses propres marges, comme un tableau. */
+  readonly rembourrage: import("@angular/core").InputSignal<"md" | "aucun">;
+  protected readonly defilante: import("@angular/core").WritableSignal<boolean>;
+  protected readonly resteAuDessus: import("@angular/core").WritableSignal<boolean>;
+  protected readonly resteAuDessous: import("@angular/core").WritableSignal<boolean>;
+  /** Precede d'un en-tete a filet permanent (forme `tuile`) : le corps y respire de 24 px. */
+  protected readonly apresUnFilet: import("@angular/core").WritableSignal<boolean>;
+  private readonly corps;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDialogContent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDialogContent, "st-dialog-content", never, {
+    "rembourrage": {
+      "alias": "rembourrage";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-
 /**
- * Barre d'actions du dialogue.
+ * Barre d'actions du dialogue : pied teinte a filet permanent (planche 5), actions a la fin.
  *
  * ⚠️ L'action de confirmation est a DROITE et l'annulation a gauche, dans cet
  * ordre dans le DOM : l'ordre de tabulation doit suivre l'ordre visuel, sinon
  * le clavier et la souris ne donnent pas le meme parcours. Inverser
- * visuellement par `row-reverse` casserait cette correspondance.
+ * visuellement par `row-reverse` casserait cette correspondance. Une action
+ * primaire ou destructrice posee EN PREMIER parmi plusieurs avertit en developpement.
+ *
+ * Sous `sm` (480 px), les actions s'empilent en pleine largeur, dans l'ordre du DOM : la
+ * confirmation en bas, sous le pouce.
+ */
+export declare class StDialogActions {
+  readonly alignement: import("@angular/core").InputSignal<"debut" | "fin" | "entre">;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDialogActions, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDialogActions, "st-dialog-actions", never, {
+    "alignement": {
+      "alias": "alignement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Ferme le dialogue qui le contient avec un resultat : une ACTION (« Annuler », « Rester
+ * connecte »), ou la croix standard posee a la main dans un gabarit sans `st-dialog-title`.
+ *
+ * ```html
+ * <button stButton variante="secondaire" [stDialogClose]="false">Annuler</button>
+ * <button stIconButton stDialogClose icone="croix" etiquette="Fermer"></button>
+ * ```
+ *
+ * - `type="button"` FORCE : dans un formulaire, un bouton sans type soumet, et la fermeture
+ *   enverrait le formulaire qu'elle devait abandonner.
+ * - La valeur de l'attribut est le RESULTAT de la fermeture ; ecrit nu (`stDialogClose`), il n'y en
+ *   a pas (`undefined`, comme Echap).
+ * - JAMAIS masque (ADR 0005 D54) : `fermable` ne gouverne que la croix de `st-dialog-title`. Un
+ *   `alertdialog` ou un dialogue `fermetureInterdite` ne se ferme QUE par ses actions : les masquer
+ *   laissait un dialogue sans reponse possible (revue du lot 229). Poser une croix a la main dans
+ *   un dialogue qui exige une reponse est une decision de l'appelant.
+ * - Le focus revient au declencheur par le CDK (`restoreFocus`), comme pour toute fermeture.
+ *
+ * Hors d'un dialogue (vitrine de galerie), le clic ne fait rien : il n'y a rien a fermer.
  */
-declare class StDialogActions {
-    readonly alignement: _angular_core.InputSignal<"debut" | "fin" | "entre">;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDialogActions, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDialogActions, "st-dialog-actions", never, { "alignement": { "alias": "alignement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+export declare class StDialogClose {
+  private readonly reference;
+  /** Resultat rendu a l'appelant ; une chaine vide (attribut nu) vaut « aucun resultat ». */
+  readonly stDialogClose: import("@angular/core").InputSignal<unknown>;
+  protected fermer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDialogClose, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StDialogClose, "button[stDialogClose]", never, {
+    "stDialogClose": {
+      "alias": "stDialogClose";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
 /** Action offerte dans le message, comme « Annuler ». */
-interface ActionDeToast {
-    readonly libelle: string;
-    readonly faire: () => void;
+export interface ActionDeToast {
+  readonly libelle: string;
+  readonly faire: () => void;
 }
 /** Ce que l'appelant demande a afficher. */
-interface DemandeDeToast {
-    /**
-     * ⚠️ Aucune donnee personnelle complete : un message reste a l'ecran le temps
-     * qu'il faut pour etre lu — et lu par-dessus l'epaule. Un IBAN, un numero de
-     * carte ou de telephone s'y ecrivent masques, comme le fait `st-masked`.
-     */
-    readonly message: string;
-    readonly ton?: TonSemantique;
-    /**
-     * ⚠️ Un message porteur d'action ne disparait PAS tout seul. WCAG 2.2.1 :
-     * un contenu qui s'efface sur minuterie doit pouvoir etre prolonge ou
-     * desactive. Un « Annuler » qui s'evanouit en quatre secondes est inutilisable
-     * pour qui lit lentement, navigue au clavier ou emploie un lecteur d'ecran —
-     * et c'est precisement la personne a qui l'annulation sert le plus.
-     */
-    readonly action?: ActionDeToast;
-    /**
-     * Duree d'affichage en millisecondes. Ignoree des qu'une action est fournie.
-     * `null` : le message reste jusqu'a sa fermeture.
-     */
-    readonly dureeMs?: number | null;
+export interface DemandeDeToast {
+  /**
+   * ⚠️ Aucune donnee personnelle complete : un message reste a l'ecran le temps
+   * qu'il faut pour etre lu — et lu par-dessus l'epaule. Un IBAN, un numero de
+   * carte ou de telephone s'y ecrivent masques, comme le fait `st-masked`.
+   */
+  readonly message: string;
+  /**
+   * Titre court, en gras au-dessus du message (planche 5). Optionnel : une confirmation tient
+   * souvent en une phrase, et un titre qui la repete n'apporte rien.
+   */
+  readonly titre?: string;
+  /**
+   * `primaire` est accepte et rendu comme `information`. `danger` reste a l'ecran jusqu'a sa
+   * fermeture, sauf `dureeMs` explicite : une erreur doit etre lue.
+   */
+  readonly ton?: TonSemantique;
+  /**
+   * ⚠️ Un message porteur d'action ne disparait PAS tout seul. WCAG 2.2.1 :
+   * un contenu qui s'efface sur minuterie doit pouvoir etre prolonge ou
+   * desactive. Un « Annuler » qui s'evanouit en quatre secondes est inutilisable
+   * pour qui lit lentement, navigue au clavier ou emploie un lecteur d'ecran —
+   * et c'est precisement la personne a qui l'annulation sert le plus.
+   */
+  readonly action?: ActionDeToast;
+  /**
+   * Duree d'affichage en millisecondes. Ignoree des qu'une action est fournie.
+   * `null` : le message reste jusqu'a sa fermeture, par un bouton « Ignorer ». Absente :
+   * `rythme.tenue.toast`, sauf pour `danger`, persistant par defaut.
+   */
+  readonly dureeMs?: number | null;
 }
 /** Un message affiche, tel que le conteneur le connait. */
-interface Toast extends DemandeDeToast {
-    readonly identifiant: number;
-    readonly ton: TonSemantique;
+export interface Toast extends DemandeDeToast {
+  readonly identifiant: number;
+  readonly ton: TonSemantique;
 }
-
 /**
  * Messages ephemeres.
  *
@@ -462,14 +1280,24 @@ interface Toast extends DemandeDeToast {
  * const messages = inject(StToast);
  * messages.montrer({ message: 'Virement enregistre', ton: 'succes' });
  * messages.montrer({
- *   message: 'Beneficiaire supprime',
+ *   titre: 'Beneficiaire supprime',
+ *   message: 'Il ne recevra plus de virement.',
  *   action: { libelle: 'Annuler', faire: () => this.retablir() },
  * });
  * ```
  *
- * ⚠️ **Un seul conteneur pour toute l'application**, cree a la premiere
- * demande. Deux piles superposees se recouvrent, et la seconde masque la
- * premiere sans que rien ne le signale.
+ * ⚠️ **Une seule pile pour toute l'application**, creee a la premiere demande, et
+ * par ce service seulement : la pile n'est pas un composant public. Deux piles
+ * superposees se recouvrent, et doublent les regions vivantes.
+ *
+ * ⚠️ **Au-dessus de tout, toujours.** La pile vit dans son PROPRE hote, enfant de
+ * `<body>`, porteur de `popover="manual"` et montre par `showPopover()` : la couche
+ * superieure du navigateur. Les volets du CDK y vivent aussi, et le dernier montre
+ * passe devant : chaque volet ajoute ensuite (un dialogue ouvert apres un message)
+ * fait remonter la pile au sommet. Un message porteur d'action reste donc cliquable
+ * sous un dialogue, et ses regions vivantes ne recoivent pas l'`aria-hidden` que le
+ * dialogue du CDK pose sur le reste de la page (il epargne les porteurs de
+ * `popover`). Sans `popover`, repli : `position: fixed` au plan des notifications.
  *
  * ⚠️ **A n'employer que pour ce qui peut etre manque.** Un message ephemere
  * n'est pas une facon d'annoncer une erreur : si l'information compte, elle
@@ -477,85 +1305,127 @@ interface Toast extends DemandeDeToast {
  * champ. La regle de tri : si la personne qui n'a pas vu le message est
  * penalisee, ce n'est pas un toast.
  */
-declare class StToast {
-    private readonly overlay;
-    private couche;
-    private conteneur;
-    constructor();
-    /** Affiche un message. Rend son identifiant, pour pouvoir le retirer. */
-    montrer(demande: DemandeDeToast): number;
-    retirer(identifiant: number): void;
-    private pile;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StToast, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
-}
-
-/**
- * Pile des messages ephemeres. Un seul exemplaire, pose par `StToast`.
- *
- * ⚠️ **Les messages visibles ne portent AUCUN role.** L'annonce passe par deux
- * regions vivantes permanentes, creees vides avec le conteneur. La premiere
- * version posait `role="status"` sur chaque message insere avec son texte :
- * c'est la sequence que les lecteurs d'ecran n'annoncent pas de facon fiable,
- * puisqu'ils rapportent les CHANGEMENTS d'une region deja observee. Les
- * confirmations — le cas courant — risquaient le silence.
- *
- * ⚠️ Il ne prend JAMAIS le focus. Un message qui s'affiche pendant une saisie
- * et vole le curseur fait perdre la frappe en cours.
- */
-declare class StToastContainer {
-    private readonly libelles;
-    private readonly pile;
-    private readonly minuteries;
-    private readonly minuteriesDAnnonce;
-    private compteur;
-    protected readonly messages: _angular_core.Signal<readonly Toast[]>;
-    protected readonly annoncePolie: _angular_core.WritableSignal<string>;
-    protected readonly annonceAssertive: _angular_core.WritableSignal<string>;
-    protected readonly libelleFermeture: _angular_core.Signal<string>;
-    constructor();
-    ajouter(demande: DemandeDeToast): number;
-    retirer(identifiant: number): void;
-    /**
-     * ⚠️ La minuterie s'arrete au survol ET au focus. Sans la seconde, une
-     * personne qui atteint le bouton au clavier le voit disparaitre sous son
-     * doigt ; sans la premiere, celle qui lit lentement n'a aucun moyen de
-     * retenir le message.
-     */
-    protected suspendre(identifiant: number): void;
-    protected reprendre(identifiant: number): void;
-    protected agir(toast: Toast): void;
-    protected iconeDe(toast: Toast): NomDIcone;
-    /**
-     * ⚠️ Un message porteur d'action n'est JAMAIS evince. La premiere version
-     * gardait les trois plus recents sans distinction : trois confirmations
-     * successives faisaient disparaitre un « Annuler » en silence — exactement ce
-     * que WCAG 2.2.1 interdit, et ce que le modele promettait d'eviter.
-     *
-     * Les plus anciens messages sans action partent d'abord. S'il ne reste que des
-     * messages porteurs d'action, la borne cede : mieux vaut une pile haute qu'une
-     * annulation perdue.
-     */
-    private borner;
-    private annoncer;
-    /**
-     * Un message porteur d'action ne s'efface pas seul : voir `DemandeDeToast`,
-     * et WCAG 2.2.1.
-     */
-    private programmer;
-    private arreterLaMinuterie;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StToastContainer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StToastContainer, "st-toast-container", never, {}, {}, never, never, true, never>;
-}
-
+export declare class StToast {
+  private readonly document;
+  private readonly application;
+  private readonly injecteur;
+  private readonly volets;
+  private conteneur;
+  private observateur;
+  private retirerLeSuiviDesPopovers;
+  constructor();
+  /** Affiche un message. Rend son identifiant, pour pouvoir le retirer. */
+  montrer(demande: DemandeDeToast): number;
+  retirer(identifiant: number): void;
+  /**
+   * Place le focus sur le message le plus recent (raccourci F6, bouton « Notifications » de la
+   * coquille). Rend `false` quand il n'y a aucun message.
+   */
+  focaliser(): boolean;
+  private pile;
+  /** Remet la pile au sommet de la couche superieure : le dernier montre passe devant. */
+  private remonter;
+  /**
+   * Chaque volet ajoute au conteneur du CDK (dialogue, menu, infobulle) se montre APRES la pile
+   * dans la couche superieure : la pile remonte derriere lui. L'observateur rappelle apres la
+   * tache qui a montre le volet, donc apres son `showPopover()`. Un volet RETIRE (dialogue ferme)
+   * rappelle aussi : `data-dialogue-ouvert` doit retomber quand plus aucun n'est modal. Un popover
+   * montre ailleurs dans la page la fait remonter de meme (lot 233, reste).
+   */
+  private suivreLesVolets;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StToast, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * Comment un message se ferme : la croix (message temporise, ou porteur d'action), ou un bouton
+ * « Ignorer » en texte (message persistant sans action, planche 5).
+ */
+export type FermetureDeToast = 'croix' | 'ignorer';
+/**
+ * UN message ephemere, tel que la pile le dessine : barre de ton de 3 px au bord de depart, icone
+ * pleine de 20 px alignee sur la premiere ligne, titre optionnel, message, action en texte et
+ * fermeture (planche 5, module 5.4).
+ *
+ * ⚠️ **Piece de rendu, pas un moyen d'afficher un message.** En application, un message passe par
+ * `StToast.montrer()` : c'est la pile qui l'annonce (regions vivantes permanentes), le temporise,
+ * le borne et rend le focus a sa fermeture. Pose seul dans une page, ce composant n'annonce rien
+ * et ne part jamais. Il est public pour qu'une vitrine (banc, documentation) le montre en place.
+ *
+ * Il ne porte AUCUN role : voir `StToast`.
+ */
+export declare class StToastMessage {
+  private readonly libelles;
+  readonly ton: import("@angular/core").InputSignal<TonSemantique>;
+  readonly titre: import("@angular/core").InputSignal<string | null | undefined>;
+  readonly message: import("@angular/core").InputSignal<string>;
+  /** Libelle de l'action (un verbe : « Annuler », « Consulter ») ; absent : aucune action. */
+  readonly libelleDAction: import("@angular/core").InputSignal<string | null | undefined>;
+  readonly fermeture: import("@angular/core").InputSignal<FermetureDeToast>;
+  /** L'action a ete activee. */
+  readonly action: import("@angular/core").OutputEmitterRef<void>;
+  /** La croix ou « Ignorer » a ete activee. */
+  readonly retrait: import("@angular/core").OutputEmitterRef<void>;
+  /** `primaire` se dessine comme `information` (brief 13). */
+  protected readonly tonRendu: import("@angular/core").Signal<"neutre" | "information" | "succes" | "avertissement" | "danger">;
+  /** Icone pleine au ton ; le neutre garde le contour, sans couleur de statut. */
+  protected readonly icone: import("@angular/core").Signal<Icone>;
+  protected readonly libelleFermeture: import("@angular/core").Signal<string>;
+  protected readonly libelleIgnorer: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StToastMessage, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StToastMessage, "st-toast-message", never, {
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+    "libelleDAction": {
+      "alias": "libelleDAction";
+      "required": false;
+      "isSignal": true;
+    };
+    "fermeture": {
+      "alias": "fermeture";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "action": "action";
+    "retrait": "retrait";
+  }, never, never, true, never>;
+}
 /** Reponse donnee a l'avertissement. */
-type ReponseDInactivite = 'prolonger' | 'deconnecter';
+export type ReponseDInactivite = 'prolonger' | 'deconnecter';
+/**
+ * Seuils ou le temps restant s'annonce, en secondes : 60 et 30 en region polie, 10 en alerte.
+ *
+ * ⚠️ JAMAIS a chaque seconde : une region qui change toutes les secondes recouvre tout ce que
+ * le lecteur d'ecran dit, y compris les deux boutons que la personne cherche justement a atteindre.
+ */
+export declare const SEUILS_D_ANNONCE_PAR_DEFAUT: readonly number[];
+/** Un seuil a cette valeur ou en dessous s'annonce en ALERTE (`role="alert"`), plus en polie. */
+export declare const SEUIL_D_ALERTE = 10;
 /** Ce que l'avertissement passe a son panneau. */
-interface DonneesDInactivite {
-    readonly restant: Signal<number>;
-    readonly identifiantDeDescription: string;
+export interface DonneesDInactivite {
+  readonly restant: Signal<number>;
+  readonly identifiantDeDescription: string;
+  /**
+   * Duree totale de l'avertissement, en secondes : la jauge se lit `restant / duree`. Absente,
+   * le premier `restant` recu (la jauge part pleine).
+   */
+  readonly duree?: number;
+  /** Seuils d'annonce ; defaut `SEUILS_D_ANNONCE_PAR_DEFAUT`. */
+  readonly seuils?: readonly number[];
 }
-
 /**
  * Avertissement avant fermeture de session pour inactivite.
  *
@@ -579,42 +1449,110 @@ interface DonneesDInactivite {
  * ⚠️ **Le clic a cote ne prolonge rien**, pour la raison que donne `StInactivite`
  * du noyau : le dialogue disparaitrait sans que la session ait ete prolongee cote
  * serveur. Il faut repondre. Echap, geste delibere, vaut « Rester connecte ».
+ *
+ * ⚠️ **Une fermeture SUBIE ne prolonge rien non plus** (A1199, A1216). Une navigation du
+ * routeur fermait l'alerte sans reponse, et ce silence valait « Rester connecte » : une
+ * redirection programmee prolongeait la session sans personne devant l'ecran. L'alerte survit
+ * desormais a la navigation (`survitALaNavigation`), et toute fermeture sans reponse la rouvre
+ * tant que le decompte court, sans rien emettre.
  */
-declare class StIdleWarning {
-    private readonly dialogues;
-    /** `null` : aucun avertissement en cours. */
-    readonly secondesRestantes: _angular_core.InputSignal<number | null>;
-    readonly prolonge: _angular_core.OutputEmitterRef<void>;
-    readonly deconnecte: _angular_core.OutputEmitterRef<void>;
-    private readonly restant;
-    private reference;
-    private readonly identifiantDeDescription;
-    constructor();
-    private ouvrir;
-    private fermerSansReponse;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StIdleWarning, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StIdleWarning, "st-idle-warning", never, { "secondesRestantes": { "alias": "secondesRestantes"; "required": false; "isSignal": true; }; }, { "prolonge": "prolonge"; "deconnecte": "deconnecte"; }, never, never, true, never>;
-}
-
-/** Contenu du dialogue d'avertissement. Ouvert par `st-idle-warning`, jamais directement. */
-declare class StIdleWarningPanel {
-    private readonly reference;
-    private readonly libelles;
-    private readonly locale;
-    protected readonly donnees: DonneesDInactivite;
-    protected readonly annonce: AnnonceLocale;
-    protected readonly titre: _angular_core.Signal<string>;
-    protected readonly message: _angular_core.Signal<string>;
-    protected readonly libelleRester: _angular_core.Signal<string>;
-    protected readonly libelleDeconnecter: _angular_core.Signal<string>;
-    constructor();
-    protected rester(): void;
-    protected deconnecter(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StIdleWarningPanel, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StIdleWarningPanel, "st-idle-warning-panel", never, {}, {}, never, never, true, never>;
-}
-
-type PositionDInfobulle = 'haut' | 'bas';
+export declare class StIdleWarning {
+  private readonly dialogues;
+  /** `null` : aucun avertissement en cours. */
+  readonly secondesRestantes: import("@angular/core").InputSignal<number | null>;
+  /**
+   * Duree totale de l'avertissement, en secondes : la jauge du panneau se lit
+   * `secondesRestantes / duree`. `null` : la premiere valeur recue (la jauge part pleine).
+   */
+  readonly duree: import("@angular/core").InputSignal<number | null>;
+  /** Seuils ou le temps restant s'annonce (defaut 60 et 30 s en polie, 10 s en alerte). */
+  readonly seuils: import("@angular/core").InputSignal<readonly number[]>;
+  readonly prolonge: import("@angular/core").OutputEmitterRef<void>;
+  readonly deconnecte: import("@angular/core").OutputEmitterRef<void>;
+  private readonly restant;
+  private reference;
+  private readonly identifiantDeDescription;
+  constructor();
+  private ouvrir;
+  private fermerSansReponse;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StIdleWarning, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StIdleWarning, "st-idle-warning", never, {
+    "secondesRestantes": {
+      "alias": "secondesRestantes";
+      "required": false;
+      "isSignal": true;
+    };
+    "duree": {
+      "alias": "duree";
+      "required": false;
+      "isSignal": true;
+    };
+    "seuils": {
+      "alias": "seuils";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "prolonge": "prolonge";
+    "deconnecte": "deconnecte";
+  }, never, never, true, never>;
+}
+/**
+ * Contenu du dialogue d'avertissement (planche 5, dialogue B). Ouvert par `st-idle-warning`,
+ * jamais directement.
+ *
+ * Anatomie : en-tete de ton `avertissement` (sablier, surtitre « Inactivite detectee », sans
+ * croix), message qui DECRIT l'alerte et dit la duree, bloc minuteur (duree `role="timer"`
+ * nommee par sa legende, jauge `st-progress` avertissement), actions aux deux bouts.
+ *
+ * ⚠️ Rien ne pulse, rien ne s'anime par seconde (EA-13) : sous 10 s, rien ne change a l'ecran ;
+ * c'est l'annonce ASSERTIVE qui porte l'escalade. La duree est en chiffres tabulaires : ni la
+ * phrase ni le bloc ne tremblent pendant le decompte.
+ *
+ * ⚠️ Echap est traite ICI, en reponse explicite « Rester connecte » : le dialogue s'ouvre avec
+ * `fermetureInterdite`, et toute autre fermeture (sans reponse) est une fermeture SUBIE, que
+ * `st-idle-warning` ne prend jamais pour une prolongation.
+ */
+export declare class StIdleWarningPanel {
+  private readonly reference;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  protected readonly donnees: DonneesDInactivite;
+  /** Seuils de 60 et 30 s : region polie. */
+  protected readonly annonce: AnnonceLocale;
+  /** Seuil de 10 s : region d'alerte (assertive). */
+  protected readonly alerte: AnnonceLocale;
+  protected readonly identifiantDeLegende: string;
+  /** Duree totale : donnee, ou le premier `restant` recu. */
+  private readonly duree;
+  protected readonly restant: import("@angular/core").Signal<number>;
+  /** La duree dite en toutes lettres (« 1 min 30 s ») : description et annonces. */
+  protected readonly dureeLue: import("@angular/core").Signal<string>;
+  /** Deux chiffres au moins, sans separateur de milliers, dans les chiffres de la locale. */
+  private readonly deuxChiffres;
+  /** La duree du bloc minuteur (« 01:30 »). */
+  protected readonly dureeAffichee: import("@angular/core").Signal<string>;
+  protected readonly jauge: import("@angular/core").Signal<number>;
+  protected readonly maximum: number;
+  protected readonly phrase: import("@angular/core").Signal<string>;
+  /**
+   * Le seuil que la derniere valeur vient de franchir, ou `null` : la valeur precedente vit dans
+   * le signal lie, plus dans la fermeture d'un effet. A l'ouverture, rien n'est franchi : le
+   * dialogue d'alerte est deja lu avec sa description.
+   */
+  private readonly franchi;
+  constructor();
+  protected rester(): void;
+  protected deconnecter(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StIdleWarningPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StIdleWarningPanel, "st-idle-warning-panel", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Cote du declencheur ou la bulle se pose d'abord : `haut` (defaut), `bas`, ou a cote dans le
+ * sens d'ecriture (`debut`, `fin`). Le cote oppose sert de repli quand la place manque ; le cote
+ * REEL est pose en `data-cote` sur la bulle, qui y oriente sa fleche.
+ */
+export type PositionDInfobulle = 'haut' | 'bas' | 'debut' | 'fin';
 /**
  * Infobulle : un complement de texte, au survol ET au focus.
  *
@@ -635,117 +1573,568 @@ type PositionDInfobulle = 'haut' | 'bas';
  * vers un element absent au moment ou le focus arrive : le lecteur d'ecran,
  * qui calcule la description a cet instant, ne lirait rien.
  *
+ * ⚠️ **Un hote FOCALISABLE.** Sans focus, la bulle n'existe pas au clavier : un `<span stTooltip>`
+ * ou un `<button disabled>` avertit en developpement. Une action indisponible s'ecrit
+ * `indisponible` (`aria-disabled`, D39) : elle reste focalisable, et sa bulle s'ouvre.
+ *
  * ⚠️ **Jamais d'information exclusive, jamais de contenu interactif.** Sur un
  * ecran tactile, il n'y a ni survol ni focus visible : l'infobulle n'existe pas.
  * Ce qu'elle dit doit pouvoir manquer. Un lien ou un bouton dedans serait
  * inatteignable — c'est un `st-popover` qu'il faut alors.
+ *
+ * Rythme (03 §3.4, P8) : au survol, `rythme.delai.survol` avant d'apparaitre —
+ * balayer une barre d'outils ne fait pas clignoter chaque bulle — ; au depart du
+ * pointeur, `rythme.delai.grace` pour rejoindre la bulle. Au focus, sans delai.
+ * Apparition et disparition en fondu seul : une bulle qui se deplacerait
+ * de 4 px ne se verrait pas bouger, seulement trembler.
  */
-declare class StTooltip {
-    private readonly element;
-    private readonly overlay;
-    private readonly descripteur;
-    private readonly document;
-    readonly stTooltip: _angular_core.InputSignal<string>;
-    readonly positionDInfobulle: _angular_core.InputSignal<PositionDInfobulle>;
-    private couche;
-    private minuterie;
-    private description;
-    private readonly echap;
-    constructor();
-    protected auSurvol(): void;
-    protected auDepartDuPointeur(): void;
-    afficher(): void;
-    masquer(): void;
-    private programmer;
-    private annulerLaMinuterie;
-    private retirerLaDescription;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StTooltip, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StTooltip, "[stTooltip]", never, { "stTooltip": { "alias": "stTooltip"; "required": true; "isSignal": true; }; "positionDInfobulle": { "alias": "positionDInfobulle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
+export declare class StTooltip {
+  private readonly element;
+  private readonly couche;
+  private readonly descripteur;
+  private readonly visibles;
+  readonly stTooltip: import("@angular/core").InputSignal<string>;
+  readonly positionDInfobulle: import("@angular/core").InputSignal<PositionDInfobulle>;
+  /** Icone decorative optionnelle, avant le texte de la bulle (planche 5 : `badge-coche`). */
+  readonly iconeDInfobulle: import("@angular/core").InputSignal<"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" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "devise" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier" | "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" | "iban" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu" | "menu-ouvert" | "message" | "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>;
+  private minuterie;
+  private description;
+  constructor();
+  protected auSurvol(): void;
+  protected auDepartDuPointeur(): void;
+  /** L'hote garde le focus, ou le pointeur est encore sur l'hote ou sur la bulle elle-meme. */
+  private encoreRequise;
+  /**
+   * Perte de focus de l'hote : WCAG 1.4.13, persistante (revue E12, BASSE). Sans cette garde, Tab
+   * hors de l'hote masquait la bulle meme si le pointeur la survolait encore (ou l'hote).
+   */
+  protected auPerteDuFocus(): void;
+  afficher(): void;
+  masquer(): void;
+  private programmer;
+  private annulerLaMinuterie;
+  private retirerLaDescription;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StTooltip, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StTooltip, "[stTooltip]", never, {
+    "stTooltip": {
+      "alias": "stTooltip";
+      "required": true;
+      "isSignal": true;
+    };
+    "positionDInfobulle": {
+      "alias": "positionDInfobulle";
+      "required": false;
+      "isSignal": true;
+    };
+    "iconeDInfobulle": {
+      "alias": "iconeDInfobulle";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /**
  * Bulle visible d'une infobulle. Posee par `stTooltip`, jamais directement.
  *
+ * Surface INVERSE du socle (planche 5, module 5.6) : rayon des surfaces, filet clair a 40 %,
+ * texte centre en 12/16 moyen (D41 : 11 px est reserve aux capitales), icone decorative
+ * optionnelle, et fleche carree de 12 px tournee vers le declencheur, orientee par le `data-cote`
+ * que la couche pose (cote REEL, repli compris). Sans `data-cote` (bulle hors couche), pas de
+ * fleche.
+ *
  * ⚠️ Muette (`aria-hidden`) : le texte est deja lu comme DESCRIPTION du
  * declencheur, par un noeud persistant. L'exposer aussi ici le ferait lire deux
  * fois.
  */
-declare class StTooltipPanel {
-    readonly texte: _angular_core.InputSignal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StTooltipPanel, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StTooltipPanel, "st-tooltip-panel", never, { "texte": { "alias": "texte"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class StTooltipPanel {
+  readonly texte: import("@angular/core").InputSignal<string>;
+  /** Icone decorative avant le texte (18 px, couleur du texte). */
+  readonly icone: import("@angular/core").InputSignal<"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" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "devise" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier" | "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" | "iban" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu" | "menu-ouvert" | "message" | "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>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StTooltipPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StTooltipPanel, "st-tooltip-panel", never, {
+    "texte": {
+      "alias": "texte";
+      "required": true;
+      "isSignal": true;
+    };
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
-type AlignementDePopover = 'debut' | 'fin';
+export type AlignementDePopover = 'debut' | 'fin';
 /**
  * Couche NON modale attachee a un declencheur : filtres rapides, detail d'une
  * ligne, petit formulaire.
  *
  * ```html
  * <button stButton [stPopoverTrigger]="filtres">Filtres</button>
- * <st-popover #filtres etiquette="Filtres des operations">…</st-popover>
+ * <st-popover #filtres titre="Filtres des operations">…</st-popover>
  * ```
  *
  * Distinct de l'infobulle, qui ne contient que du texte, et du dialogue, qui
  * piege le focus et met la page en retrait.
  *
- * ⚠️ **Non modale, donc aucun piege.** La tabulation peut en sortir, et la page
- * reste utilisable. Mais une couche que le focus a quittee flotterait sans lien
- * avec ce qu'on fait : elle se ferme quand le focus part ailleurs que sur elle
- * ou son declencheur.
+ * Nom : `titre` (visible, relie par `aria-labelledby`) ou `etiquette` (`aria-label`, invisible).
+ * L'un des deux est exige ; sans nom, la couche s'annonce « dialogue » et rien d'autre.
  *
- * ⚠️ **Deux fermetures, deux destinations du focus.** Echap rend le focus au
- * declencheur : la personne n'a rien choisi d'autre. Un clic a l'exterieur le
- * laisse la ou il a ete pose : le lui reprendre annulerait ce clic.
+ * Ce qu'elle tient (lot 232) :
+ *
+ * - a l'ouverture, le focus ENTRE : sur le premier arret de tabulation (`InteractivityChecker`,
+ *   un controle `aria-disabled="true"` passe son tour), sinon sur la couche elle-meme ;
+ * - Echap ferme et rend le focus au declencheur ;
+ * - Tab apres le dernier arret, ou Maj+Tab avant le premier, ferme : la couche vit en fin de
+ *   document, et la tabulation repart du DECLENCHEUR, dans l'ordre de la page ;
+ * - un focus pose ailleurs (clic, script) ferme SANS le reprendre ; un clic exterieur aussi ;
+ * - un second clic sur le declencheur ferme (garde de `CoucheAncree`) ;
+ * - une navigation du routeur ABOUTIE ferme (`NavigationEnd`, apres les gardes) : plus de couche
+ *   fantome sur un ecran qui change ; un declencheur emporte hors de la vue par le defilement
+ *   ferme aussi.
+ *
+ * ⚠️ **Non modale, donc aucun piege** : la page reste utilisable autour, sans voile.
+ *
+ * `fermable` (lot 265) : un bouton « Fermer » visible dans l'en-tete, pour qui n'a ni Echap ni clic
+ * exterieur evident (au toucher). `feuilleSousMd` : sous la rupture `md` de la fenetre, la couche
+ * s'ouvre en feuille inferieure, pleine largeur au bas de l'ecran, toujours sans voile.
  *
  * Meme structure que `st-menu` : le declencheur DESIGNE la couche, et l'element
  * est DEPLACE dans la couche d'overlay a l'ouverture, avec ses liaisons et son
  * etat.
  */
-declare class StPopover {
-    private readonly element;
-    private readonly overlay;
-    /** Nom accessible : sans lui, la couche s'annonce « dialogue » et rien d'autre. */
-    readonly etiquette: _angular_core.InputSignal<string>;
-    readonly alignement: _angular_core.InputSignal<AlignementDePopover>;
-    readonly identifiant: string;
-    private readonly ouvertInterne;
-    readonly ouvert: _angular_core.Signal<boolean>;
-    private couche;
-    private declencheur;
-    constructor();
-    basculerDepuis(declencheur: HTMLElement): void;
-    ouvrirDepuis(declencheur: HTMLElement): void;
-    fermer(options?: {
-        readonly rendreLeFocus?: boolean;
-    }): void;
-    protected auClavier(evenement: KeyboardEvent): void;
-    /**
-     * ⚠️ L'element actif est lu APRES la transition de focus, et non dans
-     * `relatedTarget`. Ce dernier est vide quand le focus part vers un element
-     * sans focus, et n'est pas renseigne partout ; pendant la transition elle-meme,
-     * l'element actif est encore le corps du document.
-     */
-    protected aLaPerteDuFocus(): void;
-    private detruireLaCouche;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StPopover, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StPopover, "st-popover", never, { "etiquette": { "alias": "etiquette"; "required": true; "isSignal": true; }; "alignement": { "alias": "alignement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
-}
-
-/**
- * Declencheur d'un `st-popover`.
- *
- * ⚠️ `aria-controls` vise la couche meme fermee : le lien entre les deux existe
- * pour les technologies d'assistance avant l'ouverture, et `aria-expanded` dit
- * son etat.
- */
-declare class StPopoverTrigger {
-    private readonly element;
-    readonly stPopoverTrigger: _angular_core.InputSignal<StPopover>;
-    protected basculer(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StPopoverTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StPopoverTrigger, "[stPopoverTrigger]", never, { "stPopoverTrigger": { "alias": "stPopoverTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { IDENTIFIANT_DU_TITRE, StConfirmDialog, StDialog, StDialogActions, StDialogContainer, StDialogContent, StDialogTitle, StIdleWarning, StIdleWarningPanel, StMenu, StMenuItem, StMenuTrigger, StPopover, StPopoverTrigger, StToast, StToastContainer, StToolbar, StTooltip, StTooltipPanel };
-export type { ActionDeBarre, ActionDeToast, AlignementDeMenu, AlignementDePopover, CoteDuTiroir, DemandeDeConfirmation, DemandeDeToast, DonneesDInactivite, OptionsDeDialogue, PositionDInfobulle, ReferenceDeDialogue, ReponseDInactivite, Toast, TonDElementDeMenu };
+export declare class StPopover implements OnInit {
+  private readonly element;
+  private readonly couche;
+  private readonly verificateur;
+  private readonly defilements;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  /** Nom accessible invisible (`aria-label`), quand la couche n'a pas de `titre`. */
+  readonly etiquette: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Titre visible, en `libelle` discret, qui NOMME la couche (`aria-labelledby`) : un paragraphe
+   * et non un titre de section, pour ne pas casser la hierarchie de la page.
+   */
+  readonly titre: import("@angular/core").InputSignal<string | null>;
+  /** Identifiant(s) d'un texte qui DECRIT la couche (`aria-describedby`). */
+  readonly descriptionDe: import("@angular/core").InputSignal<string | null>;
+  readonly alignement: import("@angular/core").InputSignal<AlignementDePopover>;
+  /** Un bouton « Fermer » visible dans l'en-tete (lot 265) ; il rend le focus au declencheur. */
+  readonly fermable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Sous la rupture `md` de la FENETRE, une feuille inferieure (lot 265) plutot qu'une bulle
+   * accrochee : decide a l'ouverture, par la largeur et non par le pointeur.
+   */
+  readonly feuilleSousMd: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly id: string;
+  protected readonly idDuTitre: string;
+  protected readonly titreAffiche: import("@angular/core").Signal<string | null>;
+  private readonly ouvertInterne;
+  readonly ouvert: import("@angular/core").Signal<boolean>;
+  private declencheur;
+  private defilement;
+  private repli;
+  /**
+   * Dernier geste de la personne pendant l'ouverture (pointeur ou clavier), lu par le repli de la
+   * perte de focus : un focus tombe sur le corps du document apres un CLIC n'est jamais repris.
+   */
+  private dernierGeste;
+  private ecouteDesGestes;
+  constructor();
+  ngOnInit(): void;
+  /** Identifiant de la couche, que le declencheur pose en `aria-controls` avant meme l'ouverture. */
+  identifiant(): string;
+  basculerDepuis(declencheur: HTMLElement): void;
+  ouvrirDepuis(declencheur: HTMLElement): void;
+  /**
+   * Ferme. Le focus est rendu au declencheur A LA DEMANDE (Echap), sans attendre le fondu, et
+   * seulement s'il est encore dans la couche : un focus pose ailleurs n'est jamais repris.
+   */
+  fermer(options?: {
+    readonly rendreLeFocus?: boolean;
+  }): void;
+  /**
+   * Revient a l'etat ferme, sans toucher a la couche : pour `fermer`, et quand le CDK a detache la
+   * couche de lui-meme (`auDetachement`) — le declencheur ne dit plus « ouvert » pour une couche
+   * partie.
+   */
+  private oublierLOuverture;
+  /**
+   * Revue de la reprise (MOYENNE) : le CDK ne rapporte le clic exterieur qu'au `click`, alors que le
+   * focus part vers le corps du document des le `mousedown`. Un clic tenu quelques millisecondes
+   * sur une zone non focalisable laissait le repli de `aLaPerteDuFocus` fermer AVANT, en rendant le
+   * focus au declencheur : un focus vole a un clic. Le dernier geste dit si la sortie vient du
+   * pointeur ou du clavier. En capture sur le document, retire a la fermeture.
+   */
+  private ecouterLesGestes;
+  protected auClavier(evenement: KeyboardEvent): void;
+  /**
+   * Tab apres le dernier arret, Maj+Tab avant le premier : la couche est en FIN de document, et la
+   * tabulation native sortait de la page (ou sautait au dernier element de la page). Le focus
+   * repart du declencheur, rendu AVANT l'action par defaut : Tab va a l'element qui le SUIT dans
+   * la page ; Maj+Tab s'arrete sur lui.
+   *
+   * Revue E12 (fidelite/comportement, MOYENNE) : le focus tombe sur l'HOTE (`tabindex=-1`) des
+   * qu'un clic atterrit sur une zone non focalisable de la couche (titre, padding, texte) — ou
+   * quand tous les arrets sont `aria-disabled` (D39 : ce sont quand meme des arrets, mais jamais le
+   * focus initial). Un Tab depuis l'hote fermait alors la couche au lieu d'ENTRER dans ses
+   * controles. On n'y ferme plus que sur Maj+Tab (symetrique du bord de debut) ou quand il n'y a
+   * aucun arret ; un Tab simple y entre, sur le premier.
+   */
+  private tabulation;
+  /**
+   * Vrai quand la tabulation native partie de `actif` s'arrete encore dans la couche : un arret
+   * apres lui (Tab) ou avant lui (Maj+Tab) dans l'ordre du document, selon la regle des groupes
+   * radio (`arretDepuis`). Faux au bord : la couche se ferme et la tabulation repart du declencheur.
+   */
+  private arretVoisin;
+  /**
+   * Un focus pose HORS de la couche et hors du declencheur ferme, sans le reprendre.
+   * `relatedTarget` d'abord ; vide (focus parti vers un element non focalisable, fenetre quittee),
+   * l'element actif est lu apres la transition, en repli.
+   */
+  protected aLaPerteDuFocus(evenement: FocusEvent): void;
+  /**
+   * Revue E12 (comportement, HAUTE) : un `st-menu` (ou toute autre couche) ouvert depuis un
+   * controle du popover vit dans un AUTRE `.cdk-overlay-pane` ; le focus qui y part ne quitte pas
+   * le popover. `CoucheAncree.contient` le sait par ORIGINE (le declencheur de la sous-couche est
+   * dans notre panneau), et la sous-couche se ferme AVEC le popover, quel que soit le chemin
+   * (Echap, defilement, navigation, detachement par le CDK).
+   */
+  private fermerSiHors;
+  /**
+   * Arrets de tabulation de la couche, dans l'ordre du document. Le verificateur du CDK dit ce qui
+   * est focalisable et tabulable ; la visibilite n'est pas exigee (un controle de la couche est
+   * visible des qu'elle l'est, et jsdom ne mesure rien), un sous-arbre `hidden` ou `inert` est
+   * ecarte. Un controle `aria-disabled="true"` reste un arret (D39), mais pas un focus initial.
+   *
+   * ⚠️ Revue E12 (fidelite, BASSE, REPORTEE) : `ignoreVisibility: true` compte aussi un controle
+   * masque par `display: none` ailleurs qu'un `[hidden]`/`[inert]` (un `<details>` ferme, une
+   * couche imbriquee fermee) comme un arret. Le corriger sans casser jsdom (qui ne mesure aucune
+   * boite) demande un repli de visibilite injectable ; suit dans un lot dedie plutot qu'ici.
+   */
+  private arrets;
+  /**
+   * Un declencheur que le defilement emporte hors de la vue ferme la couche : elle resterait
+   * seule, accrochee a rien de visible.
+   *
+   * ⚠️ Revue E12 (fidelite, BASSE, REPORTEE) : `ScrollDispatcher.ancestorScrolled` n'entend que la
+   * fenetre et les conteneurs enregistres `cdkScrollable` ; aucun composant du socle ne pose cette
+   * directive aujourd'hui (corps de dialogue defilant, enveloppe de tableau), donc un popover ouvert
+   * depuis l'un d'eux ne suit pas son declencheur au defilement. Ecouter `scroll` en capture sur le
+   * document reglerait le cas general, mais change la gestion de l'abonnement ET son essai (jsdom ne
+   * mesure aucune boite pour `horsDeVue`) : suit dans un lot dedie plutot qu'ici.
+   */
+  private suivreLeDefilement;
+  /** Vrai sous la rupture `md` ; sans `matchMedia` (rendu serveur, jsdom), jamais. */
+  private fenetreEtroite;
+  private horsDeVue;
+  private oublierLeDefilement;
+  private annulerLeRepli;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPopover, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StPopover, "st-popover", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "descriptionDe": {
+      "alias": "descriptionDe";
+      "required": false;
+      "isSignal": true;
+    };
+    "alignement": {
+      "alias": "alignement";
+      "required": false;
+      "isSignal": true;
+    };
+    "fermable": {
+      "alias": "fermable";
+      "required": false;
+      "isSignal": true;
+    };
+    "feuilleSousMd": {
+      "alias": "feuilleSousMd";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Declencheur d'un `st-popover`, symetrique de `[stMenuTrigger]` :
+ *
+ * ```html
+ * <button stButton [stPopoverTrigger]="filtres" iconeApres="triangle-bas">Filtres</button>
+ * <st-popover #filtres titre="Filtres des operations">…</st-popover>
+ * ```
+ *
+ * Il porte `aria-haspopup="dialog"`, `aria-expanded`, `aria-controls` (l'identifiant de la
+ * couche, meme fermee : le lien existe pour les technologies d'assistance avant l'ouverture) et
+ * `data-ouvert` pour son etat enfonce. Le clic (Entree, Espace) bascule ; la fleche bas ouvre,
+ * comme sur un declencheur de menu.
+ *
+ * ⚠️ `type="button"` est FORCE sur un `<button>` sans type : dans un formulaire, un declencheur
+ * sans type est un bouton d'envoi, et ouvrir des filtres soumettait le formulaire. Pose une fois,
+ * jamais par-dessus un type explicite (meme raison que `[stMenuTrigger]`).
+ */
+export declare class StPopoverTrigger {
+  private readonly element;
+  readonly stPopoverTrigger: import("@angular/core").InputSignal<StPopover>;
+  constructor();
+  /**
+   * Revue E12 (fidelite, MOYENNE) : sans cette garde, la fleche bas ouvrait quand meme sur un
+   * declencheur indisponible (`aria-disabled`, ou un `<button>` sans `stButton` dont la garde de
+   * clic n'existe pas). `[stMenuTrigger]` la porte deja (`estIndisponible`) ; meme symetrie ici.
+   */
+  private estIndisponible;
+  protected basculer(): void;
+  /** Fleche bas : ouvre (le focus entre dans la couche), comme `[stMenuTrigger]`. */
+  protected auClavier(evenement: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPopoverTrigger, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StPopoverTrigger, "[stPopoverTrigger]", never, {
+    "stPopoverTrigger": {
+      "alias": "stPopoverTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Le fond du bouton « Confirmer » d'une confirmation legere : JAMAIS un danger. Une action
+ * destructrice ou irreversible passe par `StDialog.confirmer` (le dialogue, ses recopies et son
+ * nombre), pas par une bulle qu'un clic distrait accepte.
+ */
+export type VarianteDeConfirmationLegere = Extract<VarianteDeBouton, 'primaire' | 'secondaire' | 'tonale'>;
+/**
+ * La confirmation legere (lot 265) : une question posee a cote du bouton, pour une action
+ * REVERSIBLE qu'un « Annuler » de message ephemere ne saurait defaire (retirer un filtre
+ * enregistre, abandonner un brouillon).
+ *
+ * ```html
+ * <button stButton variante="discret" [stPopconfirm]="'Retirer ce filtre ?'"
+ *   libelleConfirmer="Retirer" (confirme)="retirer()">Retirer</button>
+ * ```
+ *
+ * - Un `st-popover` non modal nomme par la question ; le focus va d'abord a « Annuler » (le geste
+ *   sur est le premier), Echap annule et rend le focus au declencheur.
+ * - Jamais de variante danger (`VarianteDeConfirmationLegere`) : le destructeur passe par le
+ *   dialogue, `StDialog.confirmer`.
+ * - `aria-haspopup="dialog"` et `aria-expanded` sur le declencheur ; `aria-controls` des la
+ *   premiere ouverture ; la fleche bas ouvre aussi, comme `[stPopoverTrigger]`.
+ */
+export declare class StPopconfirm {
+  private readonly element;
+  private readonly vue;
+  /** La question, deja traduite (« Retirer ce filtre ? ») : elle nomme la couche. */
+  readonly stPopconfirm: import("@angular/core").InputSignal<string>;
+  readonly precision: import("@angular/core").InputSignal<string | null>;
+  /** Defaut : « Confirmer ». */
+  readonly libelleConfirmer: import("@angular/core").InputSignal<string | null>;
+  /** Defaut : « Annuler ». */
+  readonly libelleAnnuler: import("@angular/core").InputSignal<string | null>;
+  readonly varianteDeConfirmation: import("@angular/core").InputSignal<VarianteDeConfirmationLegere>;
+  readonly confirme: import("@angular/core").OutputEmitterRef<void>;
+  readonly annule: import("@angular/core").OutputEmitterRef<void>;
+  private readonly panneau;
+  protected readonly ouvert: import("@angular/core").Signal<boolean>;
+  protected readonly controle: import("@angular/core").WritableSignal<string | null>;
+  constructor();
+  protected basculer(): void;
+  /** Fleche bas : ouvre (le focus entre dans la couche), comme `[stPopoverTrigger]`. */
+  protected auClavier(evenement: KeyboardEvent): void;
+  private estIndisponible;
+  /** Le panneau, cree a la premiere ouverture, a cote du declencheur. */
+  private creerLePanneau;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPopconfirm, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StPopconfirm, "[stPopconfirm]", never, {
+    "stPopconfirm": {
+      "alias": "stPopconfirm";
+      "required": true;
+      "isSignal": true;
+    };
+    "precision": {
+      "alias": "precision";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleConfirmer": {
+      "alias": "libelleConfirmer";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleAnnuler": {
+      "alias": "libelleAnnuler";
+      "required": false;
+      "isSignal": true;
+    };
+    "varianteDeConfirmation": {
+      "alias": "varianteDeConfirmation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "confirme": "confirme";
+    "annule": "annule";
+  }, never, never, true, never>;
+}
+/**
+ * L'aide contextuelle (lot 265) : un bouton « ? » qui ouvre une couche d'explication, pour un
+ * terme (BIC, TAEG, plafond glissant) que l'aide courte d'un champ ne suffit pas a dire.
+ *
+ * ```html
+ * <st-form-field libelle="BIC">
+ *   <st-help-button stAide sujet="BIC">
+ *     Le code d'identification de la banque du beneficiaire, 8 ou 11 caracteres.
+ *   </st-help-button>
+ *   <input stInput … />
+ * </st-form-field>
+ * ```
+ *
+ * - Un bouton natif (clavier, toucher) nomme « Aide : BIC » ; `aria-expanded` et `aria-controls`
+ *   par `[stPopoverTrigger]`. Jamais une infobulle : elle ne vit ni au toucher ni sans survol, et ne
+ *   porte que du texte court.
+ * - La couche est un `st-popover` NON MODAL, nomme par son titre, decrit par son contenu, avec un
+ *   bouton « Fermer » visible ; Echap et « Fermer » rendent le focus au bouton (WCAG 1.4.13).
+ * - Sous la rupture `md` de la fenetre, la meme couche s'ouvre en feuille inferieure.
+ * - Une seule aide ouverte a la fois : ouvrir la suivante emporte le focus, et la precedente se
+ *   ferme avec lui.
+ * - Le contenu n'est PAS relie au champ par `aria-describedby` : l'aide courte reste celle du
+ *   champ ; celle-ci est demandee.
+ */
+export declare class StHelpButton {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  /** Ce que l'aide explique, deja traduit : il entre dans le nom du bouton (« Aide : BIC »). */
+  readonly sujet: import("@angular/core").InputSignal<string>;
+  /** Le titre de la couche, qui la nomme ; defaut : le sujet. */
+  readonly titre: import("@angular/core").InputSignal<string | null>;
+  readonly alignement: import("@angular/core").InputSignal<AlignementDePopover>;
+  /** Emis a chaque ouverture : l'application peut mesurer l'usage de l'aide. */
+  readonly ouverture: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly nom: import("@angular/core").Signal<string>;
+  protected readonly titreAffiche: import("@angular/core").Signal<string>;
+  protected readonly idDuContenu: string;
+  private readonly couche;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StHelpButton, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StHelpButton, "st-help-button", never, {
+    "sujet": {
+      "alias": "sujet";
+      "required": true;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "alignement": {
+      "alias": "alignement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "ouverture": "ouverture";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Voile de chargement pose SUR un conteneur (greffe 228b, planche 9 « verre depoli ») : le
+ * contenu reste en place, attenue et intouchable, une carte dit ce qui se passe.
+ *
+ * ```html
+ * <st-loading-overlay [actif]="signature.isLoading()" titre="Signature en cours" icone="cadenas" flou>
+ *   <app-solde />
+ *   <div progression>…<st-progress [valeur]="68" etiquette="Chiffrement" /></div>
+ *   <div reassurance><st-icon nom="cercle-coche" /> Execution garantie sans doublon</div>
+ * </st-loading-overlay>
+ * ```
+ *
+ * Ce qu'il tient :
+ *
+ * - **le contenu est `inert` et `aria-busy`** tant que le voile est pose : ni clic, ni Tab, ni
+ *   lecteur d'ecran n'y entrent (le focus est IMPOSSIBLE sous le voile, pas seulement masque) ;
+ * - **le focus ne se perd pas** : s'il etait dans le contenu a la pose, il passe sur la carte ; a
+ *   la levee, il revient ou il etait (si l'element existe encore et que personne ne l'a deplace) ;
+ * - **l'annonce** passe par l'indicateur (`st-spinner`, region `status` qui dit le titre apres
+ *   `rythme.delai.annonce`) : la carte ne double pas l'annonce ;
+ * - **le flou est opt-in** (`flou`, D25) et retombe sur un voile OPAQUE quand il ne peut pas
+ *   tenir : navigateur sans `backdrop-filter`, `prefers-reduced-transparency`, contraste force.
+ *   Jamais de filtre en transition : seule l'opacite du voile arrive en fondu.
+ *
+ * ⚠️ Rien de sensible dessous : un flou de 12 px se lit encore en partie (montants, noms). Un
+ * contenu qui ne doit pas etre vu pendant l'attente ne se voile pas, il se retire.
+ *
+ * L'hote est le conteneur (`position: relative`) : sa mise en page (carte, colonne, hauteur)
+ * appartient a l'appelant, qui la pose par une classe.
+ */
+export declare class StLoadingOverlay {
+  private readonly document;
+  private readonly injecteur;
+  private readonly identifiants;
+  private readonly hote;
+  /**
+   * Identifiants du titre et de la precision : la carte (`role="group"`) les cite en
+   * `aria-labelledby`/`aria-describedby` pour porter un nom court et unique. Sans eux, la carte
+   * focalisee (generic, tabindex=-1) tirait son nom de tout son contenu — titre, progression et
+   * reassurance lus en double avec l'annonce polie du `st-spinner`.
+   */
+  protected readonly idTitre: string;
+  protected readonly idPrecision: string;
+  /** Pose le voile. */
+  readonly actif: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Ce qui se passe, en une phrase : titre de la carte et annonce de l'indicateur. */
+  readonly titre: import("@angular/core").InputSignal<string>;
+  /** Precision sous le titre (etape, duree attendue). */
+  readonly sousTitre: import("@angular/core").InputSignal<string | null>;
+  /** Glyphe immobile au centre de l'indicateur (le cadenas d'une operation scellee). */
+  readonly icone: import("@angular/core").InputSignal<Icone | null>;
+  /**
+   * Floute le contenu sous le voile (verre depoli, D25). Opt-in : le voile simple suffit
+   * partout ailleurs, et le flou coute a chaque image composee.
+   */
+  readonly flou: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly contenu;
+  private readonly carte;
+  /** L'element qui avait le focus dans le contenu a la pose du voile. */
+  private focusAvantLeVoile;
+  constructor();
+  /**
+   * ⚠️ Lu AVANT le rendu qui pose `inert` : apres, le navigateur a deja retire le focus du
+   * contenu, et on ne saurait plus d'ou il venait.
+   */
+  private aLaPose;
+  private aLaLevee;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StLoadingOverlay, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StLoadingOverlay, "st-loading-overlay", never, {
+    "actif": {
+      "alias": "actif";
+      "required": false;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": true;
+      "isSignal": true;
+    };
+    "sousTitre": {
+      "alias": "sousTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "flou": {
+      "alias": "flou";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*", "[progression]", "[reassurance]"], true, never>;
+}
+export { DIALOG_DATA as DONNEES_DE_DIALOGUE };