@starterlib/ui 0.2.0 → 0.4.0

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

@@ -1,6 +1,10 @@
-import * as _angular_core from '@angular/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, Type, TemplateRef, Signal } from '@angular/core';
 import * as i1 from '@angular/aria/menu';
-import { Ton } from '@starterlib/util';
+import { Ton, TonSemantique } from '@starterlib/util';
+import { CdkDialogContainer } from '@angular/cdk/dialog';
+export { DIALOG_DATA as DONNEES_DE_DIALOGUE } from '@angular/cdk/dialog';
+import { NomDIcone, AnnonceLocale } from '@starterlib/ui';
 
 type AlignementDeMenu = 'debut' | 'fin';
 /**
@@ -36,10 +40,10 @@ declare class StMenu {
     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>;
+    readonly etiquette: i0.InputSignal<string>;
+    readonly alignement: i0.InputSignal<AlignementDeMenu>;
     private readonly ouvertInterne;
-    readonly ouvert: _angular_core.Signal<boolean>;
+    readonly ouvert: i0.Signal<boolean>;
     private couche;
     private declencheur;
     constructor();
@@ -54,8 +58,8 @@ declare class StMenu {
     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"; }; }]>;
+    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; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Menu; inputs: { "wrap": "wrap"; "typeaheadDelay": "typeaheadDelay"; "disabled": "disabled"; }; outputs: { "itemSelected": "selection"; }; }]>;
 }
 
 /**
@@ -78,10 +82,10 @@ type TonDElementDeMenu = Extract<Ton, 'neutre' | 'danger'>;
  * actions par leur libelle, donc par leur traduction.
  */
 declare class StMenuItem {
-    readonly icone: _angular_core.InputSignal<"boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "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: {}; }]>;
+    readonly icone: i0.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" | "triangle-alerte" | "utilisateur" | null>;
+    readonly ton: i0.InputSignal<TonDElementDeMenu>;
+    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; }; }, {}, never, ["*"], true, [{ directive: typeof i1.MenuItem; inputs: { "value": "valeur"; "disabled": "desactive"; "role": "role"; }; outputs: {}; }]>;
 }
 
 /**
@@ -97,12 +101,599 @@ declare class StMenuItem {
  */
 declare class StMenuTrigger {
     private readonly element;
-    readonly menu: _angular_core.InputSignal<StMenu>;
+    readonly menu: i0.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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StMenuTrigger, "[stMenuTrigger]", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { StMenu, StMenuItem, StMenuTrigger };
-export type { AlignementDeMenu, TonDElementDeMenu };
+/**
+ * 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.
+ */
+declare const IDENTIFIANT_DU_TITRE: InjectionToken<string>;
+
+/**
+ * Ce que l'appelant decrit pour obtenir une confirmation.
+ *
+ * ⚠️ **Une confirmation d'interface n'est pas un controle.** Elle protege
+ * contre le geste distrait, pas contre quelqu'un qui appelle l'API directement.
+ * Le serveur autorise, et une action sensible — suppression de compte,
+ * 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.
+ *
+ * ⚠️ **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: i0.WritableSignal<string>;
+    /** Unique par instance : deux confirmations empilees dupliqueraient un identifiant fixe. */
+    protected readonly identifiantDeSaisie: string;
+    protected readonly ton: i0.Signal<TonSemantique>;
+    protected readonly libelleConfirmation: i0.Signal<string>;
+    protected readonly libelleAnnulation: i0.Signal<string>;
+    protected readonly libelleRecopie: i0.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: i0.Signal<boolean>;
+    protected auChangement(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;
+}
+/** Bord auquel un tiroir s'ancre. Logique, donc juste aussi en ecriture droite a gauche. */
+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;
+}
+/**
+ * Ouvre des dialogues modaux.
+ *
+ * ⚠️ Monte sur `@angular/cdk/dialog`, et c'est un choix defendu : le piegeage
+ * du focus, sa restauration au declencheur, `aria-modal`, la mise en retrait du
+ * reste de la page, Echap et le blocage du defilement sont longs a ecrire,
+ * faciles a croire finis, et c'est exactement la que l'accessibilite se perd.
+ * 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: i0.ɵɵFactoryDeclaration<StDialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Le panneau du dialogue : sa surface, 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
+ * dialogue fonctionnait donc parfaitement — role, nom, piegeage du focus,
+ * Echap — tout en s'affichant SANS FOND, le texte flottant par-dessus la page.
+ * Aucun test ne pouvait le voir : jsdom ne calcule pas la mise en page, et les
+ * tests verifiaient le comportement, pas l'aspect.
+ *
+ * ⚠️ Un conteneur maison plutot qu'une feuille de style globale a importer :
+ * une SPA qui oublierait l'import retrouverait exactement le meme defaut, et
+ * l'oubli ne se verrait qu'a l'ecran. Ici, l'apparence voyage avec le
+ * composant.
+ *
+ * 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: i0.ɵɵFactoryDeclaration<StDialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StDialogContainer, "st-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Titre du dialogue. Il porte l'identifiant que la configuration a designe en
+ * `aria-labelledby` : c'est lui qui NOMME le dialogue.
+ *
+ * ⚠️ 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.
+ */
+declare class StDialogTitle {
+    protected readonly identifiant: string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StDialogTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StDialogTitle, "st-dialog-title", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Corps du dialogue, defilant quand il deborde.
+ *
+ * ⚠️ Le defilement est ICI et non sur le dialogue entier : titre et actions
+ * doivent rester visibles. Un dialogue long dont les boutons partent hors de
+ * 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
+ * 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
+ * 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.
+ */
+declare class StDialogContent {
+    /** `aucun` pour un contenu qui gere ses propres marges, comme un tableau. */
+    readonly rembourrage: i0.InputSignal<"aucun" | "md">;
+    protected readonly defilante: i0.WritableSignal<boolean>;
+    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.
+ *
+ * ⚠️ 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.
+ */
+declare class StDialogActions {
+    readonly alignement: i0.InputSignal<"debut" | "fin" | "entre">;
+    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>;
+}
+
+/** Action offerte dans le message, comme « Annuler ». */
+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;
+}
+/** Un message affiche, tel que le conteneur le connait. */
+interface Toast extends DemandeDeToast {
+    readonly identifiant: number;
+    readonly ton: TonSemantique;
+}
+
+/**
+ * Messages ephemeres.
+ *
+ * ```ts
+ * const messages = inject(StToast);
+ * messages.montrer({ message: 'Virement enregistre', ton: 'succes' });
+ * messages.montrer({
+ *   message: 'Beneficiaire supprime',
+ *   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.
+ *
+ * ⚠️ **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
+ * doit rester a l'ecran — `st-banner` pour la page, `st-inline-message` pour un
+ * 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: i0.ɵɵFactoryDeclaration<StToast, never>;
+    static ɵprov: i0.ɵɵ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: i0.Signal<readonly Toast[]>;
+    protected readonly annoncePolie: i0.WritableSignal<string>;
+    protected readonly annonceAssertive: i0.WritableSignal<string>;
+    protected readonly libelleFermeture: i0.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: i0.ɵɵFactoryDeclaration<StToastContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StToastContainer, "st-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+/** Reponse donnee a l'avertissement. */
+type ReponseDInactivite = 'prolonger' | 'deconnecter';
+/** Ce que l'avertissement passe a son panneau. */
+interface DonneesDInactivite {
+    readonly restant: Signal<number>;
+    readonly identifiantDeDescription: string;
+}
+
+/**
+ * Avertissement avant fermeture de session pour inactivite.
+ *
+ * ```html
+ * <st-idle-warning
+ *   [secondesRestantes]="inactivite.secondesRestantes()"
+ *   (prolonge)="inactivite.prolonger()"
+ *   (deconnecte)="session.deconnecter()"
+ * />
+ * ```
+ *
+ * ⚠️ **Composant de PRESENTATION.** Il n'injecte pas `StInactivite` : `ui` ne
+ * depend pas de `@starterlib/core` (ADR 0003). Il s'ouvre quand
+ * `secondesRestantes` cesse d'etre `null`, et se ferme quand il y revient. La
+ * decision de fermer la session reste au noyau, qui la prend cote serveur.
+ *
+ * ⚠️ **Un `alertdialog`, focus sur « Rester connecte ».** Le motif ARIA veut le
+ * focus sur l'action la moins destructrice : une touche Entree reflexe doit
+ * garder la session, jamais la fermer.
+ *
+ * ⚠️ **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 ».
+ */
+declare class StIdleWarning {
+    private readonly dialogues;
+    /** `null` : aucun avertissement en cours. */
+    readonly secondesRestantes: i0.InputSignal<number | null>;
+    readonly prolonge: i0.OutputEmitterRef<void>;
+    readonly deconnecte: i0.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; }; }, { "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: i0.Signal<string>;
+    protected readonly message: i0.Signal<string>;
+    protected readonly libelleRester: i0.Signal<string>;
+    protected readonly libelleDeconnecter: i0.Signal<string>;
+    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>;
+}
+
+type PositionDInfobulle = 'haut' | 'bas';
+/**
+ * Infobulle : un complement de texte, au survol ET au focus.
+ *
+ * ```html
+ * <button stIconButton icone="corbeille" etiquette="Supprimer" stTooltip="Supprimer le beneficiaire"></button>
+ * ```
+ *
+ * WCAG 1.4.13, les trois exigences, chacune tenue ici :
+ *
+ * - **Refermable** : Echap la masque SANS deplacer le focus, et sans fermer le
+ *   dialogue qui la contiendrait — la premiere touche est pour elle.
+ * - **Survolable** : le pointeur peut passer du declencheur a la bulle sans
+ *   qu'elle disparaisse.
+ * - **Persistante** : elle reste tant que le survol ou le focus dure.
+ *
+ * ⚠️ **Le texte est une DESCRIPTION posee des le depart**, par un noeud
+ * persistant. Un `aria-describedby` qui viserait la bulle elle-meme pointerait
+ * vers un element absent au moment ou le focus arrive : le lecteur d'ecran,
+ * qui calcule la description a cet instant, ne lirait rien.
+ *
+ * ⚠️ **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.
+ */
+declare class StTooltip {
+    private readonly element;
+    private readonly overlay;
+    private readonly descripteur;
+    private readonly document;
+    readonly stTooltip: i0.InputSignal<string>;
+    readonly positionDInfobulle: i0.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: 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; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Bulle visible d'une infobulle. Posee par `stTooltip`, jamais directement.
+ *
+ * ⚠️ 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: i0.InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StTooltipPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StTooltipPanel, "st-tooltip-panel", never, { "texte": { "alias": "texte"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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>
+ * ```
+ *
+ * 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.
+ *
+ * ⚠️ **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.
+ *
+ * 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: i0.InputSignal<string>;
+    readonly alignement: i0.InputSignal<AlignementDePopover>;
+    readonly identifiant: string;
+    private readonly ouvertInterne;
+    readonly ouvert: i0.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: i0.ɵɵFactoryDeclaration<StPopover, never>;
+    static ɵcmp: i0.ɵɵ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: i0.InputSignal<StPopover>;
+    protected basculer(): 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>;
+}
+
+export { IDENTIFIANT_DU_TITRE, StConfirmDialog, StDialog, StDialogActions, StDialogContainer, StDialogContent, StDialogTitle, StIdleWarning, StIdleWarningPanel, StMenu, StMenuItem, StMenuTrigger, StPopover, StPopoverTrigger, StToast, StToastContainer, StTooltip, StTooltipPanel };
+export type { ActionDeToast, AlignementDeMenu, AlignementDePopover, CoteDuTiroir, DemandeDeConfirmation, DemandeDeToast, DonneesDInactivite, OptionsDeDialogue, PositionDInfobulle, ReferenceDeDialogue, ReponseDInactivite, Toast, TonDElementDeMenu };