@starterlib/ui 0.1.1 → 0.3.0

package/types/starterlib-ui.d.ts

@@ -1,7 +1,111 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider, TemplateRef } from '@angular/core';
-import { Montant } from '@starterlib/util';
+import { InjectionToken, Signal, Provider, DestroyRef, Resource, TemplateRef } from '@angular/core';
+import { Ton, Montant, TonSemantique, ChoixDeTheme, Langue, EtatDeBloc } from '@starterlib/util';
+export { ETATS_DE_BLOC, EtatDeBloc } from '@starterlib/util';
 
+/**
+ * Les textes que les composants portent eux-memes.
+ *
+ * ⚠️ Ce ne sont pas « les textes de l'application » : le socle ne connait aucun
+ * ecran. Ce sont les quelques mots qu'un composant doit dire sans que
+ * l'appelant ait a les fournir a chaque usage — le nom d'un bouton de copie,
+ * l'annonce d'un chargement, la mention d'une ouverture dans une autre fenetre.
+ * Tout le reste est un `input` de l'appelant.
+ *
+ * Les entrees a trou sont des FONCTIONS, et non des gabarits a interpoler :
+ * l'ordre des mots change d'une langue a l'autre (« IBAN se terminant par
+ * 2606 » contre « IBAN ending in 2606 »), et une fonction laisse la langue
+ * decider, sans inventer un mini-langage de gabarit dans la librairie.
+ */
+interface LibellesUi {
+    /** Indicateur d'activite, et etat de chargement d'un bloc. */
+    readonly chargementEnCours: string;
+    readonly erreurSurvenue: string;
+    readonly aucunResultat: string;
+    readonly horsConnexion: string;
+    /** Erreur : action de rejeu, et etiquette de l'identifiant technique. */
+    readonly reessayer: string;
+    readonly identifiantDeTrace: string;
+    /** Etiquette du code machine affiche a cote du message. */
+    readonly codeTechnique: string;
+    /** Valeur technique copiable. */
+    readonly copier: string;
+    readonly copieEffectuee: string;
+    readonly copieImpossible: string;
+    /** Valeur masquee. */
+    readonly afficher: string;
+    readonly masquer: string;
+    readonly valeurMasqueeANouveau: string;
+    readonly natureIban: string;
+    readonly natureCarte: string;
+    readonly natureTelephone: string;
+    readonly seTerminantPar: (nature: string, quatreDerniers: string) => string;
+    /** Lien sortant, etiquette de retrait, temps relatif. */
+    readonly nouvelleFenetre: string;
+    readonly retirer: string;
+    /** Structure */
+    readonly filDAriane: string;
+    readonly allerAuContenu: string;
+    readonly navigationPrincipale: string;
+    /** Transverses */
+    readonly theme: string;
+    readonly themeSysteme: string;
+    readonly themeClair: string;
+    readonly themeSombre: string;
+    readonly langue: string;
+    readonly reessayerDans: (duree: string) => string;
+    readonly reessayerMaintenant: string;
+    readonly sessionBientotExpiree: string;
+    readonly sessionExpireDans: (duree: string) => string;
+    readonly resterConnecte: string;
+    readonly seDeconnecter: string;
+    readonly fermerLeMessage: string;
+    /** Dialogues */
+    readonly confirmer: string;
+    readonly annuler: string;
+    readonly recopierPourConfirmer: (texte: string) => string;
+    readonly aLInstant: string;
+}
+/**
+ * Defaut francais, identique mot pour mot aux textes ecrits en dur jusqu'a la
+ * 0.1.1 : une application qui ne fournit rien ne change pas de comportement.
+ *
+ * Il existe pour que le socle reste utilisable sans i18n, pas pour dispenser
+ * d'en avoir une. Une application bilingue DOIT fournir son propre dictionnaire
+ * sous forme de signal — sinon la moitie de l'interface reste en francais quand
+ * l'utilisateur passe a l'anglais, et rien ne le signale.
+ */
+/**
+ * ⚠️ Les textes AFFICHES portent leurs accents. La regle « sans accents » du
+ * depot vise la documentation et les commentaires, jamais ce que lit la
+ * personne qui utilise l'application : « Reessayer » ou « Aucun resultat » sont
+ * des fautes a l'ecran, et une synthese vocale les prononce de travers. La 0.2.0
+ * les a livres ainsi. Les accents s'ecrivent en sequence d'echappement, comme
+ * l'apostrophe typographique, pour garder la source en ASCII.
+ */
+declare const LIBELLES_FR: LibellesUi;
+/** Traduction anglaise du meme dictionnaire. La paire est obligatoire. */
+declare const LIBELLES_EN: LibellesUi;
+
+/**
+ * Locale de formatage des montants, des dates et des nombres, **sous forme de
+ * signal**.
+ *
+ * ⚠️ Pourquoi pas `LOCALE_ID` : il est fige au demarrage de l'application. Or
+ * l'ADR 0014 du backend exige de changer de langue SANS recharger — la coquille
+ * detient la langue, et tout doit basculer d'un coup. Un composant qui lit
+ * `LOCALE_ID` continuerait d'afficher « 1 234,50 € » dans une interface passee
+ * a l'anglais.
+ *
+ * Le defaut lit `LOCALE_ID` : une application qui ne fournit rien garde le
+ * comportement d'avant, simplement sans pouvoir changer de langue a chaud.
+ */
+declare const ST_LOCALE: InjectionToken<Signal<string>>;
+/**
+ * Textes portes par les composants eux-memes, sous forme de signal pour la
+ * meme raison que la locale.
+ */
+declare const ST_LIBELLES: InjectionToken<Signal<LibellesUi>>;
 /**
  * Chemin du sprite SVG des icones, **fourni par l'application**.
  *
@@ -28,6 +132,29 @@ declare const CHEMIN_DU_SPRITE: InjectionToken<string>;
  * pourraient viser deux sprites differents.
  */
 declare function fournirCheminDuSprite(chemin: string): Provider;
+/** Ce que l'application fournit a `@starterlib/ui`, et rien d'autre. */
+interface ConfigurationUi {
+    /** Obligatoire : voir `CHEMIN_DU_SPRITE`. */
+    readonly cheminDuSprite: string;
+    /**
+     * Locale de formatage. Un signal quand la langue change a l'execution, ce
+     * qui est le cas des que la coquille porte un selecteur de langue.
+     */
+    readonly locale?: Signal<string> | string;
+    /** Textes portes par les composants. Un signal, pour la meme raison. */
+    readonly libelles?: Signal<LibellesUi> | LibellesUi;
+    /** Fuseau de rendu des dates. Vient de la personne connectee, pas du poste. */
+    readonly fuseau?: string;
+}
+/**
+ * Configure `@starterlib/ui` pour toute l'application.
+ *
+ * ⚠️ A appeler dans l'HOTE uniquement. Dans un assemblage federe, un remote qui
+ * la rappellerait poserait un second jeu de valeurs dans son injecteur de
+ * route : deux locales, deux dictionnaires, et la moitie de l'ecran resterait
+ * dans l'ancienne langue apres une bascule.
+ */
+declare function provideStarterUi(configuration: ConfigurationUi): Provider[];
 /**
  * Marque la presence d'une region vivante possedee par un ancetre, en pratique
  * le composant `st-state`.
@@ -47,14 +174,61 @@ declare const REGION_VIVANTE_PARENTE: InjectionToken<true>;
 declare const FUSEAU_PAR_DEFAUT: InjectionToken<string>;
 
 /**
- * Les cinq etats que tout bloc consommant l'API doit traiter. Le type les
- * enumere pour qu'aucun ne s'oublie : un `switch` non exhaustif ne compile pas.
+ * Texte d'une petite region vivante propre a un composant.
+ *
+ * ```ts
+ * protected readonly annonce = new AnnonceLocale(inject(DestroyRef));
+ * // gabarit : <span class="st-vh" aria-live="polite">{{ annonce.texte() }}</span>
+ * ```
+ *
+ * ⚠️ La region doit exister VIDE dans le gabarit des la creation du composant ;
+ * cette classe ne gere que son texte.
+ *
+ * ⚠️ Nee de deux defauts de `st-code` en 0.2.0 : un `onDestroy` enregistre a
+ * chaque clic, et une confirmation identique reposee dans la meme tache — la
+ * seconde copie n'etait jamais annoncee.
+ */
+declare class AnnonceLocale {
+    private readonly contenu;
+    private minuteries;
+    readonly texte: _angular_core.Signal<string>;
+    constructor(destruction: DestroyRef);
+    annoncer(message: string): void;
+    private arreter;
+}
+
+/** Issue d'une copie. */
+type IssueDeCopie = 'copie' | 'indisponible' | 'refusee';
+/**
+ * Ecrit un texte dans le presse-papiers.
+ *
+ * ⚠️ Trois issues, et non deux. `navigator.clipboard` n'existe qu'en contexte
+ * securise (HTTPS, ou `localhost`) : absent, c'est `indisponible`. Present, il
+ * peut encore refuser — permission, document sans focus — et c'est `refusee`.
+ * Confondre les deux conduit a cacher un bouton qui aurait fonctionne au clic
+ * suivant, ou a laisser croire qu'une copie a eu lieu.
+ *
+ * ⚠️ Ce qui entre dans le presse-papiers en sort difficilement : les
+ * gestionnaires d'historique le conservent, et la synchronisation entre
+ * appareils le propage. Jamais de secret — mot de passe, jeton, code a usage
+ * unique — et une donnee sensible seulement a la demande explicite de la
+ * personne.
+ */
+declare function copierDansLePressePapiers(document: Document, texte: string): Promise<IssueDeCopie>;
+/** Vrai si le navigateur expose un presse-papiers ecrivable par script. */
+declare function pressePapiersDisponible(document: Document): boolean;
+
+/**
+ * Formate une duree en secondes : « 45 s », « 2 min 05 s ».
+ *
+ * Unites courtes de la langue donnee, par `Intl.NumberFormat` : l'ordre, les
+ * espaces et les abreviations suivent la locale, sans table maison.
  */
-type EtatDeBloc = 'chargement' | 'erreur' | 'vide' | 'hors-ligne' | 'succes';
-declare const ETATS_DE_BLOC: readonly EtatDeBloc[];
+declare function formaterDuree(totalEnSecondes: number, locale: string): string;
 
 type TailleDIcone = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-type TonDIcone = 'courant' | 'discret' | 'primaire' | 'succes' | 'avertissement' | 'danger';
+/** Une icone prend n'importe quel ton sauf `inverse`, qui vise un fond plein. */
+type TonDIcone = Exclude<Ton, 'inverse'>;
 /**
  * Icone tiree d'un sprite SVG servi en meme origine.
  *
@@ -69,13 +243,13 @@ type TonDIcone = 'courant' | 'discret' | 'primaire' | 'succes' | 'avertissement'
  */
 declare class StIcon {
     private readonly cheminDuSprite;
-    readonly nom: _angular_core.InputSignal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    readonly nom: _angular_core.InputSignal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
     readonly taille: _angular_core.InputSignal<TailleDIcone>;
     readonly ton: _angular_core.InputSignal<TonDIcone>;
     /** `null` : l'icone est decorative et reste muette pour les lecteurs. */
     readonly etiquette: _angular_core.InputSignal<string | null>;
-    readonly estDecorative: _angular_core.Signal<boolean>;
-    readonly reference: _angular_core.Signal<string>;
+    protected readonly estDecorative: _angular_core.Signal<boolean>;
+    protected readonly reference: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StIcon, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StIcon, "st-icon", never, { "nom": { "alias": "nom"; "required": true; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -103,7 +277,7 @@ type GraisseDeTexte = 'normale' | 'moyenne' | 'semi';
 declare class StText {
     readonly variante: _angular_core.InputSignal<VarianteDeTexte>;
     readonly graisse: _angular_core.InputSignal<GraisseDeTexte>;
-    readonly enLigne: _angular_core.InputSignal<boolean>;
+    readonly enLigne: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Nombre de lignes au-dela duquel le texte est coupe.
      *
@@ -134,13 +308,13 @@ declare class StHeading {
     readonly taille: _angular_core.InputSignal<TailleDeTitre | null>;
     /** Cible d'un `aria-labelledby` : une region se nomme par son titre. */
     readonly identifiant: _angular_core.InputSignal<string | null>;
-    readonly tailleEffective: _angular_core.Signal<TailleDeTitre>;
+    protected readonly tailleEffective: _angular_core.Signal<TailleDeTitre>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StHeading, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StHeading, "st-heading", never, { "niveau": { "alias": "niveau"; "required": true; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "identifiant": { "alias": "identifiant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 type TailleDeSpinner = 'sm' | 'md' | 'lg';
-type TonDeSpinner = 'courant' | 'primaire' | 'inverse';
+type TonDeSpinner = Extract<Ton, 'neutre' | 'primaire' | 'inverse'>;
 /**
  * Indicateur d'activite indeterminee.
  *
@@ -156,15 +330,18 @@ type TonDeSpinner = 'courant' | 'primaire' | 'inverse';
  */
 declare class StSpinner {
     private readonly regionParente;
+    private readonly libelles;
     readonly taille: _angular_core.InputSignal<TailleDeSpinner>;
     readonly ton: _angular_core.InputSignal<TonDeSpinner>;
-    readonly etiquette: _angular_core.InputSignal<string>;
-    readonly sAnnonce: _angular_core.Signal<boolean>;
+    /** `null` : le texte vient du dictionnaire de l'application. */
+    readonly etiquette: _angular_core.InputSignal<string | null>;
+    protected readonly etiquetteLue: _angular_core.Signal<string>;
+    protected readonly sAnnonce: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSpinner, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSpinner, "st-spinner", never, { "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type TonDeProgression = 'primaire' | 'succes' | 'danger';
+type TonDeProgression = Extract<Ton, 'primaire' | 'succes' | 'danger'>;
 /**
  * Barre de progression, determinee ou indeterminee.
  *
@@ -181,10 +358,10 @@ declare class StProgress {
     readonly ton: _angular_core.InputSignal<TonDeProgression>;
     /** Texte lu a la place du pourcentage quand celui-ci n'est pas parlant. */
     readonly texteDeValeur: _angular_core.InputSignal<string | null>;
-    readonly estIndeterminee: _angular_core.Signal<boolean>;
+    protected readonly estIndeterminee: _angular_core.Signal<boolean>;
     /** Omis quand la progression est indeterminee : l'annoncer serait faux. */
-    readonly valeurAnnoncee: _angular_core.Signal<number | null>;
-    readonly pourcentage: _angular_core.Signal<number>;
+    protected readonly valeurAnnoncee: _angular_core.Signal<number | null>;
+    protected readonly pourcentage: _angular_core.Signal<number>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StProgress, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StProgress, "st-progress", never, { "valeur": { "alias": "valeur"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": true; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "texteDeValeur": { "alias": "texteDeValeur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -204,14 +381,20 @@ declare class StSkeleton {
     readonly variante: _angular_core.InputSignal<VarianteDeSquelette>;
     readonly lignes: _angular_core.InputSignal<number>;
     readonly colonnes: _angular_core.InputSignal<number>;
-    readonly anime: _angular_core.InputSignal<boolean>;
-    readonly indicesDeLigne: _angular_core.Signal<number[]>;
-    readonly indicesDeColonne: _angular_core.Signal<number[]>;
+    readonly anime: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly indicesDeLigne: _angular_core.Signal<number[]>;
+    protected readonly indicesDeColonne: _angular_core.Signal<number[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSkeleton, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSkeleton, "st-skeleton", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "lignes": { "alias": "lignes"; "required": false; "isSignal": true; }; "colonnes": { "alias": "colonnes"; "required": false; "isSignal": true; }; "anime": { "alias": "anime"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type VarianteDeBouton = 'primaire' | 'secondaire' | 'discret' | 'destructeur';
+/**
+ * ⚠️ Une variante dit quel FOND le bouton prend, pas ce qu'il signifie ; c'est
+ * un axe distinct du ton, et il le reste. Mais son quatrieme membre s'appelle
+ * `danger` comme partout ailleurs : il n'y a aucune raison qu'un bouton rouge
+ * et une pastille rouge portent deux mots differents.
+ */
+type VarianteDeBouton = 'primaire' | 'secondaire' | 'discret' | 'danger';
 type TailleDeBouton = 'sm' | 'md' | 'lg';
 /**
  * Bouton du socle, pose en ATTRIBUT sur un `<button>` natif.
@@ -235,27 +418,38 @@ type TailleDeBouton = 'sm' | 'md' | 'lg';
 declare class StButton {
     readonly variante: _angular_core.InputSignal<VarianteDeBouton>;
     readonly taille: _angular_core.InputSignal<TailleDeBouton>;
-    readonly pleineLargeur: _angular_core.InputSignal<boolean>;
-    readonly iconeAvant: _angular_core.InputSignal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur" | null>;
-    readonly iconeApres: _angular_core.InputSignal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur" | null>;
+    readonly pleineLargeur: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly iconeAvant: _angular_core.InputSignal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur" | null>;
+    readonly iconeApres: _angular_core.InputSignal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur" | null>;
     /**
      * Action en cours. Tant qu'il vaut vrai, les clics sont avales : c'est le
      * mecanisme d'anti double soumission. L'appelant doit le lever DES la
      * soumission, pas a l'arrivee de la reponse.
      */
-    readonly chargement: _angular_core.InputSignal<boolean>;
+    readonly chargement: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * L'action existe mais n'est pas disponible : une condition n'est pas encore
+     * remplie.
+     *
+     * ⚠️ `aria-disabled` et NON l'attribut natif `disabled`, qui retire le bouton
+     * de l'ordre de tabulation. Une personne au clavier ne l'atteindrait plus, et
+     * ne decouvrirait donc jamais la condition qui le bloque — le bouton aurait
+     * simplement disparu de son parcours. Ici il reste atteignable, annonce comme
+     * indisponible, et ses clics sont avales.
+     */
+    readonly indisponible: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Le ton suit le FOND du bouton, et non le bouton en general : sur une
      * variante posee sur la surface (`secondaire`, qui est le defaut, et
      * `discret`), un indicateur en ton inverse tombait a 1,00:1 — invisible.
      */
-    readonly tonDuChargement: _angular_core.Signal<TonDeSpinner>;
+    protected readonly tonDuChargement: _angular_core.Signal<TonDeSpinner>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StButton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StButton, "button[stButton]", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "pleineLargeur": { "alias": "pleineLargeur"; "required": false; "isSignal": true; }; "iconeAvant": { "alias": "iconeAvant"; "required": false; "isSignal": true; }; "iconeApres": { "alias": "iconeApres"; "required": false; "isSignal": true; }; "chargement": { "alias": "chargement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StButton, "button[stButton]", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "pleineLargeur": { "alias": "pleineLargeur"; "required": false; "isSignal": true; }; "iconeAvant": { "alias": "iconeAvant"; "required": false; "isSignal": true; }; "iconeApres": { "alias": "iconeApres"; "required": false; "isSignal": true; }; "chargement": { "alias": "chargement"; "required": false; "isSignal": true; }; "indisponible": { "alias": "indisponible"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-type VarianteDeBoutonIcone = 'discret' | 'secondaire' | 'destructeur';
+type VarianteDeBoutonIcone = Extract<VarianteDeBouton, 'discret' | 'secondaire' | 'danger'>;
 /**
  * Bouton reduit a une icone, pose en attribut sur un `<button>` natif.
  *
@@ -264,15 +458,22 @@ type VarianteDeBoutonIcone = 'discret' | 'secondaire' | 'destructeur';
  * de facon fiable.
  */
 declare class StIconButton {
-    readonly icone: _angular_core.InputSignal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    readonly icone: _angular_core.InputSignal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
     /** Nom accessible du controle. Sans lui, l'icone ne dit rien. */
     readonly etiquette: _angular_core.InputSignal<string>;
     readonly variante: _angular_core.InputSignal<VarianteDeBoutonIcone>;
     readonly taille: _angular_core.InputSignal<"sm" | "md">;
-    /** `null` : le bouton n'est pas a deux etats et n'annonce aucune pression. */
-    readonly enfonce: _angular_core.ModelSignal<boolean | null>;
+    /**
+     * `null` : le bouton n'est pas a deux etats et n'annonce aucune pression.
+     *
+     * ⚠️ Une ENTREE, et non un `model`. Le composant ne bascule rien de lui-meme :
+     * l'etat enfonce reflete une donnee que l'appelant detient. En `model`,
+     * `[(enfonce)]` compilait et ne remontait jamais — une liaison bidirectionnelle
+     * muette est pire qu'absente, puisqu'elle se relit comme fonctionnelle.
+     */
+    readonly enfonce: _angular_core.InputSignal<boolean | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StIconButton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StIconButton, "button[stIconButton]", never, { "icone": { "alias": "icone"; "required": true; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": true; "isSignal": true; }; "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "enfonce": { "alias": "enfonce"; "required": false; "isSignal": true; }; }, { "enfonce": "enfonceChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StIconButton, "button[stIconButton]", never, { "icone": { "alias": "icone"; "required": true; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": true; "isSignal": true; }; "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "enfonce": { "alias": "enfonce"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type VarianteDeLien = 'texte' | 'autonome' | 'discret';
@@ -287,11 +488,16 @@ type VarianteDeLien = 'texte' | 'autonome' | 'discret';
  * quiconque regarde l'ecran.
  */
 declare class StLink {
+    private readonly libelles;
     readonly variante: _angular_core.InputSignal<VarianteDeLien>;
     /** Ouvre dans un nouvel onglet, et l'annonce dans le nom accessible. */
-    readonly externe: _angular_core.InputSignal<boolean>;
-    /** Mention lue par les lecteurs d'ecran quand le lien sort du site. */
-    readonly mentionExterne: _angular_core.InputSignal<string>;
+    readonly externe: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Mention lue par les lecteurs d'ecran quand le lien sort du site.
+     * `null` : le texte vient du dictionnaire de l'application.
+     */
+    readonly mentionExterne: _angular_core.InputSignal<string | null>;
+    protected readonly mentionExterneLue: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StLink, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StLink, "a[stLink]", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "externe": { "alias": "externe"; "required": false; "isSignal": true; }; "mentionExterne": { "alias": "mentionExterne"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -309,7 +515,7 @@ declare class StButtonGroup {
     readonly etiquette: _angular_core.InputSignal<string>;
     readonly orientation: _angular_core.InputSignal<"horizontale" | "verticale">;
     /** Boutons jointifs, rayons fusionnes. */
-    readonly attache: _angular_core.InputSignal<boolean>;
+    readonly attache: _angular_core.InputSignalWithTransform<boolean, unknown>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StButtonGroup, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StButtonGroup, "st-button-group", never, { "etiquette": { "alias": "etiquette"; "required": true; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "attache": { "alias": "attache"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -325,25 +531,26 @@ declare class StButtonGroup {
  */
 declare class StCode {
     private readonly document;
-    private readonly destruction;
+    private readonly libelles;
     readonly valeur: _angular_core.InputSignal<string>;
-    readonly etiquette: _angular_core.InputSignal<string>;
-    readonly copiable: _angular_core.InputSignal<boolean>;
-    readonly libelleCopier: _angular_core.InputSignal<string>;
-    readonly messageDeConfirmation: _angular_core.InputSignal<string>;
+    readonly copiable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** `null` : les textes viennent du dictionnaire de l'application. */
+    readonly etiquette: _angular_core.InputSignal<string | null>;
+    readonly libelleCopier: _angular_core.InputSignal<string | null>;
+    readonly messageDeConfirmation: _angular_core.InputSignal<string | null>;
+    protected readonly etiquetteLue: _angular_core.Signal<string>;
+    protected readonly libelleCopierLu: _angular_core.Signal<string>;
     readonly copie: _angular_core.OutputEmitterRef<string>;
-    private readonly confirmation;
-    private minuterie;
-    readonly texteDeConfirmation: _angular_core.Signal<string>;
+    protected readonly annonce: AnnonceLocale;
     /**
      * Le bouton n'apparait que si le navigateur sait copier. Sans presse-papiers,
      * un bouton qui ne fait rien vaut moins que la selection manuelle, que la
      * feuille garde possible (`user-select: all`).
      */
-    readonly copiePossible: _angular_core.Signal<boolean>;
+    protected readonly copiePossible: _angular_core.Signal<boolean>;
     protected auClicDeCopie(): Promise<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StCode, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCode, "st-code", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": false; "isSignal": true; }; "copiable": { "alias": "copiable"; "required": false; "isSignal": true; }; "libelleCopier": { "alias": "libelleCopier"; "required": false; "isSignal": true; }; "messageDeConfirmation": { "alias": "messageDeConfirmation"; "required": false; "isSignal": true; }; }, { "copie": "copie"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCode, "st-code", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "copiable": { "alias": "copiable"; "required": false; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": false; "isSignal": true; }; "libelleCopier": { "alias": "libelleCopier"; "required": false; "isSignal": true; }; "messageDeConfirmation": { "alias": "messageDeConfirmation"; "required": false; "isSignal": true; }; }, { "copie": "copie"; }, never, never, true, never>;
 }
 
 type TypeMasque = 'iban' | 'carte' | 'telephone';
@@ -359,24 +566,35 @@ type TypeMasque = 'iban' | 'carte' | 'telephone';
  * journal.
  */
 declare class StMasked {
-    private readonly destruction;
+    private readonly libelles;
     readonly valeur: _angular_core.InputSignal<string>;
     readonly type: _angular_core.InputSignal<TypeMasque>;
     readonly revele: _angular_core.ModelSignal<boolean>;
-    readonly revelationAutorisee: _angular_core.InputSignal<boolean>;
+    readonly revelationAutorisee: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly dureeDeRevelationEnSecondes: _angular_core.InputSignal<number>;
-    readonly libelleAfficher: _angular_core.InputSignal<string>;
-    readonly libelleMasquer: _angular_core.InputSignal<string>;
+    /** `null` : les textes viennent du dictionnaire de l'application. */
+    readonly libelleAfficher: _angular_core.InputSignal<string | null>;
+    readonly libelleMasquer: _angular_core.InputSignal<string | null>;
     readonly revelation: _angular_core.OutputEmitterRef<{
         type: TypeMasque;
     }>;
-    private readonly annonce;
-    readonly texteDAnnonce: _angular_core.Signal<string>;
+    /**
+     * ⚠️ Par `AnnonceLocale`, et non par un signal pose directement. La 0.2.0
+     * reposait « Valeur masquee a nouveau » a l'identique : aucune mutation, donc
+     * une seconde remise en masque jamais annoncee.
+     */
+    protected readonly annonce: AnnonceLocale;
     private minuterie;
-    readonly valeurMasquee: _angular_core.Signal<string>;
-    readonly valeurAffichee: _angular_core.Signal<string>;
-    readonly nomAccessible: _angular_core.Signal<string>;
-    readonly libelleDuBouton: _angular_core.Signal<string>;
+    constructor();
+    protected readonly valeurMasquee: _angular_core.Signal<string>;
+    protected readonly valeurAffichee: _angular_core.Signal<string>;
+    /**
+     * La nature et la tournure viennent du dictionnaire : l'ordre des mots change
+     * d'une langue a l'autre, « IBAN se terminant par 2606 » contre « IBAN ending
+     * in 2606 ». Une chaine a trous ne suffirait pas.
+     */
+    protected readonly nomAccessible: _angular_core.Signal<string>;
+    protected readonly libelleDuBouton: _angular_core.Signal<string>;
     private valeurLisible;
     protected basculer(): void;
     private masquer;
@@ -398,11 +616,11 @@ declare class StMasked {
 declare class StMoney {
     private readonly locale;
     readonly valeur: _angular_core.InputSignal<Montant>;
-    readonly signeExplicite: _angular_core.InputSignal<boolean>;
-    readonly sansDevise: _angular_core.InputSignal<boolean>;
+    readonly signeExplicite: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly sansDevise: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly taille: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl">;
-    readonly signe: _angular_core.Signal<"negatif" | "positif" | "nul">;
-    readonly texte: _angular_core.Signal<string>;
+    protected readonly signe: _angular_core.Signal<"negatif" | "positif" | "nul">;
+    protected readonly texte: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StMoney, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StMoney, "st-money", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "signeExplicite": { "alias": "signeExplicite"; "required": false; "isSignal": true; }; "sansDevise": { "alias": "sansDevise"; "required": false; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -425,12 +643,33 @@ declare class StDate {
     readonly valeur: _angular_core.InputSignal<string | Date>;
     readonly format: _angular_core.InputSignal<FormatDeDate>;
     readonly fuseau: _angular_core.InputSignal<string | null>;
+    /**
+     * Une DATE DE CALENDRIER (`2026-09-12`) n'est pas un instant : une date de
+     * naissance, une echeance ou un jour de valeur n'ont pas d'heure, et ne
+     * doivent pas changer de jour selon le fuseau de qui les regarde.
+     *
+     * ⚠️ Le piege est dans la norme : `new Date('2026-09-12')` vaut minuit UTC,
+     * donc le 11 septembre partout a l'ouest de Greenwich. Une echeance affichee
+     * la veille est un defaut que personne ne voit depuis l'Europe.
+     */
+    private readonly estDateDeCalendrier;
     private readonly date;
-    readonly estValide: _angular_core.Signal<boolean>;
-    readonly iso: _angular_core.Signal<string | null>;
-    readonly texte: _angular_core.Signal<string>;
+    protected readonly estValide: _angular_core.Signal<boolean>;
+    /**
+     * Le fuseau de rendu. Pour une date de calendrier, c'est UTC : la valeur a
+     * ete construite a minuit UTC, la relire en UTC rend donc le jour ecrit.
+     */
+    private readonly fuseauDeRendu;
+    /**
+     * Une date de calendrier porte `2026-09-12`, sans heure ni decalage : c'est
+     * la forme que la norme HTML attend, et la seule qui ne mente pas.
+     */
+    protected readonly iso: _angular_core.Signal<string | null>;
+    /** Une date sans heure ne peut pas en afficher une. */
+    private readonly optionsDeFormat;
+    protected readonly texte: _angular_core.Signal<string>;
     /** Forme longue, lue par les technologies d'assistance. */
-    readonly texteAccessible: _angular_core.Signal<string | null>;
+    protected readonly texteAccessible: _angular_core.Signal<string | null>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDate, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDate, "st-date", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "fuseau": { "alias": "fuseau"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -447,20 +686,21 @@ declare class StDate {
  */
 declare class StRelativeTime {
     private readonly locale;
+    private readonly libelles;
     private readonly fuseau;
     readonly valeur: _angular_core.InputSignal<string | Date>;
-    readonly rafraichir: _angular_core.InputSignal<boolean>;
+    readonly rafraichir: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Au-dela de ce nombre de jours, la date absolue est plus parlante. */
     readonly seuilAbsoluEnJours: _angular_core.InputSignal<number>;
     private readonly destruction;
     private readonly maintenant;
     constructor();
     private dateEnMillisecondes;
-    readonly estValide: _angular_core.Signal<boolean>;
-    readonly iso: _angular_core.Signal<string | null>;
-    readonly depasseLeSeuil: _angular_core.Signal<boolean>;
-    readonly texte: _angular_core.Signal<string>;
-    readonly texteAccessible: _angular_core.Signal<string>;
+    protected readonly estValide: _angular_core.Signal<boolean>;
+    protected readonly iso: _angular_core.Signal<string | null>;
+    protected readonly depasseLeSeuil: _angular_core.Signal<boolean>;
+    protected readonly texte: _angular_core.Signal<string>;
+    protected readonly texteAccessible: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StRelativeTime, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StRelativeTime, "st-relative-time", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "rafraichir": { "alias": "rafraichir"; "required": false; "isSignal": true; }; "seuilAbsoluEnJours": { "alias": "seuilAbsoluEnJours"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -477,17 +717,22 @@ declare class StRelativeTime {
 declare class StCount {
     private readonly locale;
     readonly valeur: _angular_core.InputSignal<number>;
-    readonly ton: _angular_core.InputSignal<"courant" | "discret">;
+    readonly ton: _angular_core.InputSignal<"neutre" | "discret">;
     /** `null` : jamais d'abreviation. */
     readonly abregerAuDela: _angular_core.InputSignal<number | null>;
-    readonly estAbrege: _angular_core.Signal<boolean>;
-    readonly texteComplet: _angular_core.Signal<string>;
-    readonly texte: _angular_core.Signal<string>;
+    protected readonly estAbrege: _angular_core.Signal<boolean>;
+    protected readonly texteComplet: _angular_core.Signal<string>;
+    protected readonly texte: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StCount, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCount, "st-count", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "abregerAuDela": { "alias": "abregerAuDela"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type TonDeStatut = 'neutre' | 'info' | 'succes' | 'avertissement' | 'danger';
+/**
+ * ⚠️ `primaire` et non « info » : les deux designaient deja la meme couleur
+ * d'accent, et rien ne distinguait un statut « info » d'un statut « primaire »
+ * ailleurs dans le socle.
+ */
+type TonDeStatut = TonSemantique;
 /**
  * Pastille de statut.
  *
@@ -505,13 +750,13 @@ declare class StStatusPill {
     readonly statut: _angular_core.InputSignal<string>;
     /** Texte deja traduit par l'appelant : le socle ne traduit rien. */
     readonly libelle: _angular_core.InputSignal<string>;
-    readonly icone: _angular_core.InputSignal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
-    readonly ton: _angular_core.InputSignal<TonDeStatut>;
+    readonly icone: _angular_core.InputSignal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    readonly ton: _angular_core.InputSignal<TonSemantique>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StStatusPill, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StStatusPill, "st-status-pill", never, { "statut": { "alias": "statut"; "required": true; "isSignal": true; }; "libelle": { "alias": "libelle"; "required": true; "isSignal": true; }; "icone": { "alias": "icone"; "required": true; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type TonDeBadge = 'neutre' | 'primaire' | 'succes' | 'avertissement' | 'danger';
+type TonDeBadge = TonSemantique;
 /**
  * Pastille de comptage superposee a un autre element.
  *
@@ -524,10 +769,10 @@ type TonDeBadge = 'neutre' | 'primaire' | 'succes' | 'avertissement' | 'danger';
 declare class StBadge {
     readonly valeur: _angular_core.InputSignal<string | number | null>;
     readonly max: _angular_core.InputSignal<number>;
-    readonly ton: _angular_core.InputSignal<TonDeBadge>;
+    readonly ton: _angular_core.InputSignal<TonSemantique>;
     /** Point seul, sans chiffre : signale une nouveaute sans la quantifier. */
-    readonly point: _angular_core.InputSignal<boolean>;
-    readonly texte: _angular_core.Signal<string>;
+    readonly point: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly texte: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StBadge, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StBadge, "st-badge", never, { "valeur": { "alias": "valeur"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "point": { "alias": "point"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -542,12 +787,14 @@ declare class StBadge {
  */
 declare class StTag {
     private readonly element;
+    private readonly libelles;
     readonly libelle: _angular_core.InputSignal<string>;
-    readonly supprimable: _angular_core.InputSignal<boolean>;
-    readonly ton: _angular_core.InputSignal<"primaire" | "neutre">;
-    readonly prefixeDeSuppression: _angular_core.InputSignal<string>;
+    readonly supprimable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ton: _angular_core.InputSignal<"neutre" | "primaire">;
+    /** `null` : le texte vient du dictionnaire de l'application. */
+    readonly prefixeDeSuppression: _angular_core.InputSignal<string | null>;
     readonly supprime: _angular_core.OutputEmitterRef<void>;
-    readonly libelleDeSuppression: _angular_core.Signal<string>;
+    protected readonly libelleDeSuppression: _angular_core.Signal<string>;
     protected auRetrait(): void;
     /**
      * Cible, dans l'ordre : le bouton de l'etiquette suivante, celui de la
@@ -575,12 +822,12 @@ declare class StAvatar {
      * `true` quand le nom figure deja a cote de l'avatar, ce qui est le cas
      * courant : l'avatar devient alors decoratif et se tait.
      */
-    readonly nomAdjacent: _angular_core.InputSignal<boolean>;
+    readonly nomAdjacent: _angular_core.InputSignalWithTransform<boolean, unknown>;
     private readonly imageEchouee;
-    readonly afficheLImage: _angular_core.Signal<boolean>;
-    readonly initiales: _angular_core.Signal<string>;
+    protected readonly afficheLImage: _angular_core.Signal<boolean>;
+    protected readonly initiales: _angular_core.Signal<string>;
     /** Vide quand le nom est deja lisible a cote : eviter la double lecture. */
-    readonly texteAlternatif: _angular_core.Signal<string>;
+    protected readonly texteAlternatif: _angular_core.Signal<string>;
     protected auxEchecsDImage(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StAvatar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StAvatar, "st-avatar", never, { "nom": { "alias": "nom"; "required": true; "isSignal": true; }; "sourceImage": { "alias": "sourceImage"; "required": false; "isSignal": true; }; "taille": { "alias": "taille"; "required": false; "isSignal": true; }; "forme": { "alias": "forme"; "required": false; "isSignal": true; }; "nomAdjacent": { "alias": "nomAdjacent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -596,7 +843,7 @@ declare class StAvatar {
 declare class StEmpty {
     readonly titre: _angular_core.InputSignal<string>;
     readonly description: _angular_core.InputSignal<string | null>;
-    readonly icone: _angular_core.InputSignal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    readonly icone: _angular_core.InputSignal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
     readonly niveauDuTitre: _angular_core.InputSignal<NiveauDeTitre>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StEmpty, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StEmpty, "st-empty", never, { "titre": { "alias": "titre"; "required": true; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "icone": { "alias": "icone"; "required": false; "isSignal": true; }; "niveauDuTitre": { "alias": "niveauDuTitre"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
@@ -617,6 +864,7 @@ type VarianteDErreur = 'hors-ligne' | 'serveur' | 'client';
  */
 declare class StError {
     private readonly regionParente;
+    private readonly libelles;
     readonly variante: _angular_core.InputSignal<VarianteDErreur>;
     /** Code machine stable, tel que rendu par le backend. */
     readonly code: _angular_core.InputSignal<string>;
@@ -624,15 +872,19 @@ declare class StError {
     readonly message: _angular_core.InputSignal<string>;
     readonly traceId: _angular_core.InputSignal<string | null>;
     readonly niveauDuTitre: _angular_core.InputSignal<NiveauDeTitre>;
-    readonly rejouable: _angular_core.InputSignal<boolean>;
-    readonly libelleRejeu: _angular_core.InputSignal<string>;
-    readonly rejeuEnCours: _angular_core.InputSignal<boolean>;
-    readonly etiquetteDeTrace: _angular_core.InputSignal<string>;
+    readonly rejouable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rejeuEnCours: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** `null` : les textes viennent du dictionnaire de l'application. */
+    readonly libelleRejeu: _angular_core.InputSignal<string | null>;
+    readonly etiquetteDeTrace: _angular_core.InputSignal<string | null>;
     readonly rejeu: _angular_core.OutputEmitterRef<void>;
-    readonly icone: _angular_core.Signal<"hors-ligne" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "copie" | "corbeille" | "croix" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
-    readonly sAnnonce: _angular_core.Signal<boolean>;
+    protected readonly libelleRejeuLu: _angular_core.Signal<string>;
+    protected readonly etiquetteDeTraceLue: _angular_core.Signal<string>;
+    protected readonly etiquetteDuCode: _angular_core.Signal<string>;
+    protected readonly icone: _angular_core.Signal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    protected readonly sAnnonce: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StError, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StError, "st-error", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "code": { "alias": "code"; "required": true; "isSignal": true; }; "titre": { "alias": "titre"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "traceId": { "alias": "traceId"; "required": false; "isSignal": true; }; "niveauDuTitre": { "alias": "niveauDuTitre"; "required": false; "isSignal": true; }; "rejouable": { "alias": "rejouable"; "required": false; "isSignal": true; }; "libelleRejeu": { "alias": "libelleRejeu"; "required": false; "isSignal": true; }; "rejeuEnCours": { "alias": "rejeuEnCours"; "required": false; "isSignal": true; }; "etiquetteDeTrace": { "alias": "etiquetteDeTrace"; "required": false; "isSignal": true; }; }, { "rejeu": "rejeu"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StError, "st-error", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "code": { "alias": "code"; "required": true; "isSignal": true; }; "titre": { "alias": "titre"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "traceId": { "alias": "traceId"; "required": false; "isSignal": true; }; "niveauDuTitre": { "alias": "niveauDuTitre"; "required": false; "isSignal": true; }; "rejouable": { "alias": "rejouable"; "required": false; "isSignal": true; }; "rejeuEnCours": { "alias": "rejeuEnCours"; "required": false; "isSignal": true; }; "libelleRejeu": { "alias": "libelleRejeu"; "required": false; "isSignal": true; }; "etiquetteDeTrace": { "alias": "etiquetteDeTrace"; "required": false; "isSignal": true; }; }, { "rejeu": "rejeu"; }, never, never, true, never>;
 }
 
 /**
@@ -650,51 +902,694 @@ declare class StError {
 declare class StOfflineBanner {
     readonly message: _angular_core.InputSignal<string>;
     readonly libelleRejeu: _angular_core.InputSignal<string | null>;
-    readonly rejeuEnCours: _angular_core.InputSignal<boolean>;
+    readonly rejeuEnCours: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly rejeu: _angular_core.OutputEmitterRef<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<StOfflineBanner, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StOfflineBanner, "st-offline-banner", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "libelleRejeu": { "alias": "libelleRejeu"; "required": false; "isSignal": true; }; "rejeuEnCours": { "alias": "rejeuEnCours"; "required": false; "isSignal": true; }; }, { "rejeu": "rejeu"; }, never, never, true, never>;
 }
 
+type ReliefDeCarte = 'plat' | 'pose' | 'flottant';
+type RembourrageDeCarte = 'aucun' | 'sm' | 'md' | 'lg';
+/**
+ * Surface qui regroupe un contenu.
+ *
+ * ⚠️ **Elle n'est jamais cliquable en entier**, et c'est un refus delibere. Une
+ * carte munie d'un `(click)` produit, pour qui ecoute la page, UN seul controle
+ * dont le nom accessible est tout le texte de la carte — titre, montant, date,
+ * mention legale d'un trait. Elle est aussi injoignable au clavier sans
+ * `tabindex`, qui la ferait alors annoncer deux fois.
+ *
+ * Le motif correct : un lien ou un bouton unique DANS la carte, etendu
+ * visuellement a toute sa surface par la classe `st-carte__lien-etendu`. Le
+ * nom accessible reste celui du lien, le clavier fonctionne sans rien ajouter,
+ * et la zone cliquable est la meme.
+ *
+ * ```html
+ * <st-card>
+ *   <st-heading [niveau]="3">
+ *     <a class="st-carte__lien-etendu" routerLink="/comptes/12">Compte courant</a>
+ *   </st-heading>
+ *   <st-money [montant]="solde" />
+ * </st-card>
+ * ```
+ */
+declare class StCard {
+    readonly relief: _angular_core.InputSignal<ReliefDeCarte>;
+    readonly rembourrage: _angular_core.InputSignal<RembourrageDeCarte>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCard, "st-card", never, { "relief": { "alias": "relief"; "required": false; "isSignal": true; }; "rembourrage": { "alias": "rembourrage"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Regroupement de contenu, expose comme REPERE de navigation quand il porte un
+ * nom.
+ *
+ * ⚠️ Le point qui decide de tout : `role="region"` n'est expose comme repere
+ * que s'il a un NOM ACCESSIBLE. Sans nom, la plupart des lecteurs d'ecran
+ * l'ignorent purement et simplement — la balise est la, le repere n'existe pas,
+ * et rien ne le signale. Le composant refuse donc de poser le role quand il ne
+ * peut pas le nommer : une section anonyme reste un simple bloc, ce qu'elle est
+ * reellement.
+ *
+ * Deux facons de la nommer, et la seconde vaut mieux : `titreDe` pointe le
+ * titre deja affiche, ce qui garde un seul texte a traduire et a maintenir.
+ *
+ * ```html
+ * <st-heading [niveau]="2" identifiant="titre-operations">Operations</st-heading>
+ * <st-section titreDe="titre-operations">…</st-section>
+ * ```
+ */
+declare class StSection {
+    /** Nom accessible ecrit a la main. A preferer `titreDe` quand un titre existe. */
+    readonly etiquette: _angular_core.InputSignal<string | null>;
+    /** Identifiant du titre qui nomme la section. Prime sur `etiquette`. */
+    readonly titreDe: _angular_core.InputSignal<string | null>;
+    readonly espacement: _angular_core.InputSignal<"sm" | "md" | "lg" | "aucun">;
+    protected readonly estUnRepere: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSection, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSection, "st-section", never, { "etiquette": { "alias": "etiquette"; "required": false; "isSignal": true; }; "titreDe": { "alias": "titreDe"; "required": false; "isSignal": true; }; "espacement": { "alias": "espacement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type OrientationDeSeparateur = 'horizontale' | 'verticale';
+/**
+ * Trait de separation.
+ *
+ * ⚠️ **Decoratif par defaut, et c'est le bon defaut.** Un `<hr>` porte le role
+ * `separator` de facon implicite, que les lecteurs d'ecran annoncent. Sur une
+ * page qui en compte huit — ce qui est courant dans une liste de reglages — la
+ * lecture est ponctuee de huit « separateur » qui n'apprennent rien.
+ *
+ * Le role ne se pose que lorsque le trait porte vraiment du sens : il separe
+ * alors deux GROUPES que rien d'autre ne distingue, comme les sections d'un
+ * menu. Regle de tri : si le retirer ne retire aucune information, il est
+ * decoratif.
+ */
+declare class StDivider {
+    readonly orientation: _angular_core.InputSignal<OrientationDeSeparateur>;
+    /** Le trait separe deux groupes distincts, et doit donc etre annonce. */
+    readonly porteurDeSens: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDivider, "st-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "porteurDeSens": { "alias": "porteurDeSens"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Titre de page : le `h1`, et les actions qui lui sont attachees.
+ *
+ * ⚠️ Il rend une **vraie balise `h1`**, la ou `st-heading` porte
+ * `role="heading"` sur son hote. La raison est precise : `StNavigation` de
+ * `@starterlib/core` vise le titre de niveau 1 pour y poser le focus apres une
+ * navigation, et une vraie balise est ce que trouvent aussi les extensions, le
+ * mode lecture et les outils d'audit. Un `h1` par page, jamais deux.
+ *
+ * ⚠️ **Il ne gere PAS le focus**, et ce n'est pas un oubli. Le noyau le fait
+ * deja a chaque changement de route. Deux mecanismes qui deplacent le focus a
+ * la meme milliseconde ne se completent pas : ils se battent, et le gagnant
+ * depend de l'ordre de rendu — donc du hasard.
+ *
+ * ```html
+ * <st-page-title>
+ *   Mes operations
+ *   <button stButton variante="primaire" actions>Exporter</button>
+ * </st-page-title>
+ * ```
+ */
+declare class StPageTitle {
+    /** Texte secondaire sous le titre. Jamais porteur d'information critique. */
+    readonly precision: _angular_core.InputSignal<string | null>;
+    /** Cible d'un `aria-labelledby` : une region se nomme par son titre. */
+    readonly identifiant: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StPageTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StPageTitle, "st-page-title", never, { "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "identifiant": { "alias": "identifiant"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[actions]"], true, never>;
+}
+
+/** Un maillon du fil. Sans `lien`, il n'est pas cliquable. */
+interface MaillonDeFil {
+    readonly libelle: string;
+    /**
+     * Chemin INTERNE de l'application, suivi par le routeur.
+     *
+     * ⚠️ Jamais une adresse externe : un fil d'Ariane decrit ou l'on se trouve
+     * dans CETTE application. Passe par le routeur, un domaine tiers n'est pas
+     * une destination possible.
+     */
+    readonly lien?: string;
+}
+/**
+ * Fil d'Ariane.
+ *
+ * ⚠️ **Le dernier maillon n'est pas un lien.** C'est la page courante : un lien
+ * vers l'endroit ou l'on se trouve deja n'apporte rien, et il ajoute un arret
+ * de tabulation sur chaque page du site. Il porte `aria-current="page"`, qui
+ * est ce que le lecteur d'ecran annonce a sa place.
+ *
+ * ⚠️ **Les separateurs sont poses en `aria-hidden`.** Un chevron ou une barre
+ * oblique laisses dans l'arbre d'accessibilite se lit « barre oblique » entre
+ * chaque maillon : « Accueil barre oblique Comptes barre oblique Operations ».
+ * Les poser en contenu engendre par CSS ne suffit pas — Chrome et Firefox
+ * exposent `content` a l'arbre d'accessibilite.
+ *
+ * ⚠️ La liste est ORDONNEE (`ol`) : l'ordre des maillons est l'information.
+ *
+ * ⚠️ **Les liens passent par le routeur.** La premiere version posait des
+ * `href` bruts : dans une SPA, un clic quittait l'application, repassait par la
+ * coquille du BFF et perdait tout l'etat en memoire — sur le composant de
+ * navigation le plus clique apres le menu.
+ */
+declare class StBreadcrumb {
+    private readonly libelles;
+    readonly maillons: _angular_core.InputSignal<readonly MaillonDeFil[]>;
+    /** `null` : le texte vient du dictionnaire de l'application. */
+    readonly etiquette: _angular_core.InputSignal<string | null>;
+    /** Caractere de separation. Muet pour les technologies d'assistance. */
+    readonly separateur: _angular_core.InputSignal<string>;
+    protected readonly etiquetteLue: _angular_core.Signal<string>;
+    /** Le dernier maillon est la page courante, jamais un lien. */
+    protected readonly derniereIndice: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StBreadcrumb, "st-breadcrumb", never, { "maillons": { "alias": "maillons"; "required": true; "isSignal": true; }; "etiquette": { "alias": "etiquette"; "required": false; "isSignal": true; }; "separateur": { "alias": "separateur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Identifiant par defaut du contenu principal, pose par `st-app-shell`. */
+declare const IDENTIFIANT_DU_CONTENU_PRINCIPAL = "contenu-principal";
+/**
+ * Lien d'evitement : aller au contenu sans traverser la navigation.
+ *
+ * WCAG 2.4.1. Sans lui, chaque page impose a qui navigue au clavier de
+ * traverser l'en-tete et tout le menu avant d'atteindre ce qu'il est venu lire —
+ * trente arrets de tabulation, a chaque changement de page.
+ *
+ * ⚠️ **Le focus est pose par script, et la navigation par ancre est annulee.**
+ * Deux raisons, et chacune suffit :
+ *
+ * 1. Un `href="#contenu"` se resout contre `<base href>`. Sous
+ *    `/ui/<interface>/`, il vise `/ui/<interface>/#contenu` : un rechargement
+ *    complet de la coquille, au lieu d'un saut dans la page.
+ * 2. Suivre une ancre deplace la vue sans toujours deplacer le FOCUS. La
+ *    tabulation suivante repart alors du lien d'evitement, et le saut n'a servi
+ *    a rien.
+ *
+ * Le `href` reste pose : c'est lui qui fait du lien un lien, pour le lecteur
+ * d'ecran comme pour le clic du milieu.
+ *
+ * ⚠️ Il doit etre le PREMIER element focalisable du document. Le composant ne
+ * peut pas l'imposer ; `st-app-shell` le fait.
+ */
+declare class StSkipLink {
+    private readonly document;
+    private readonly libelles;
+    /** Identifiant de l'element a atteindre. */
+    readonly cible: _angular_core.InputSignal<string>;
+    /** `null` : le texte vient du dictionnaire de l'application. */
+    readonly libelle: _angular_core.InputSignal<string | null>;
+    protected readonly libelleLu: _angular_core.Signal<string>;
+    protected readonly ancre: _angular_core.Signal<string>;
+    protected aller(evenement: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSkipLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StSkipLink, "st-skip-link", never, { "cible": { "alias": "cible"; "required": false; "isSignal": true; }; "libelle": { "alias": "libelle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Coquille d'une application : lien d'evitement, en-tete, navigation, contenu
+ * principal, pied de page.
+ *
+ * ```html
+ * <st-app-shell>
+ *   <ng-container entete>…</ng-container>
+ *   <ng-container navigation>…</ng-container>
+ *   <router-outlet />
+ *   <ng-container pied>…</ng-container>
+ * </st-app-shell>
+ * ```
+ *
+ * ⚠️ Son role est de garantir les REPERES, et un seul de chaque. Une page qui
+ * compte deux `main` — frequent quand une micro-SPA pose le sien dans celui de
+ * la coquille — prive le lecteur d'ecran du raccourci « aller au contenu
+ * principal » : il ne sait plus lequel viser. Les remotes ne posent donc
+ * jamais de `main`, `header` ni `footer` de premier niveau.
+ *
+ * ⚠️ Le lien d'evitement est rendu EN PREMIER, avant l'en-tete : c'est la seule
+ * place ou il sert. Place apres, il faut deja avoir traverse ce qu'il permet
+ * d'eviter.
+ *
+ * Le contenu principal porte l'identifiant vise par le lien d'evitement.
+ * Le focus de navigation, lui, vise le titre de niveau 1 : voir `StNavigation`
+ * de `@starterlib/core`. Les deux se completent — l'un au chargement d'une
+ * page, l'autre a chaque changement de route.
+ *
+ * ⚠️ La coquille ne pose PAS de `<nav>` autour de la navigation : c'est
+ * `st-sidenav` qui porte ce repere. Pose ici aussi, il s'imbriquerait — le
+ * lecteur d'ecran annoncerait « navigation, navigation » — et resterait vide
+ * sur petit ecran, quand le contenu part dans le tiroir.
+ */
+declare class StAppShell {
+    protected readonly identifiantDuContenu = "contenu-principal";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StAppShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StAppShell, "st-app-shell", never, {}, {}, never, ["[entete]", "[navigation]", "*", "[pied]"], true, never>;
+}
+
+/**
+ * Contenu de l'en-tete : bouton de navigation, marque, puis actions.
+ *
+ * ```html
+ * <st-app-shell>
+ *   <st-header entete>
+ *     <button bascule stButton [stSidenavToggle]="navigation">Menu</button>
+ *     <a marque routerLink="/"><st-logo nom="Banque Exemple" clair="/logo.svg" /></a>
+ *     <st-lang-switch [courante]="langue.courante()" (choisie)="langue.changer($event)" />
+ *     <button stButton [stMenuTrigger]="compte">Mon compte</button>
+ *   </st-header>
+ * </st-app-shell>
+ * ```
+ *
+ * ⚠️ **Aucun repere pose ici.** Le `header` de `st-app-shell` est deja le
+ * repere « banniere » ; en ajouter un second dans le premier ferait annoncer
+ * deux bannieres.
+ *
+ * ⚠️ **Composition, pas assemblage.** Il ne cree ni menu, ni bascule, ni logo :
+ * il les place. C'est ce qui le garde dans le tronc — importer `st-menu` l'aurait
+ * fait sortir vers un point d'entree secondaire — et qui laisse chaque SPA
+ * choisir ses actions.
+ *
+ * L'ordre du DOM est l'ordre de lecture et de tabulation : bouton de
+ * navigation, marque, actions. Il n'est jamais inverse par le style.
+ */
+declare class StHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StHeader, "st-header", never, {}, {}, never, ["[bascule]", "[marque]", "*"], true, never>;
+}
+
+type TonDeBanniere = TonSemantique;
+/**
+ * Message de page, persistant jusqu'a ce qu'on le ferme.
+ *
+ * Distinct de `st-offline-banner`, qui dit un fait qu'on ne peut pas fermer, et
+ * de `st-error`, qui remplace un contenu au lieu de l'accompagner.
+ *
+ * ⚠️ **Elle est une region vivante, et ce n'est pas redondant au chargement.**
+ * Un lecteur d'ecran annonce les MUTATIONS d'une region qu'il observe deja :
+ * une banniere presente des l'affichage est lue avec la page, une fois, puis
+ * son apparition ulterieure est annoncee. Le meme mecanisme sert les deux cas.
+ *
+ * ⚠️ Le ton `danger` passe en `alert` (assertif) : une operation qui vient
+ * d'echouer doit interrompre. Les autres restent en `status`, sinon une
+ * confirmation couperait la lecture en cours et ferait perdre sa place.
+ *
+ * ⚠️ Comme `st-spinner` et `st-error`, elle se tait dans une region vivante
+ * existante : sans cela, le lecteur annonce deux fois le meme message.
+ */
+declare class StBanner {
+    private readonly element;
+    private readonly regionParente;
+    private readonly libelles;
+    readonly ton: _angular_core.InputSignal<TonSemantique>;
+    readonly message: _angular_core.InputSignal<string>;
+    /** Titre court au-dessus du message. Le message seul suffit le plus souvent. */
+    readonly titre: _angular_core.InputSignal<string | null>;
+    readonly fermable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** `null` : le texte vient du dictionnaire de l'application. */
+    readonly libelleFermeture: _angular_core.InputSignal<string | null>;
+    readonly ferme: _angular_core.OutputEmitterRef<void>;
+    protected readonly icone: _angular_core.Signal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    protected readonly libelleFermetureLu: _angular_core.Signal<string>;
+    protected readonly roleLu: _angular_core.Signal<"status" | "alert" | null>;
+    /**
+     * ⚠️ Le focus est DEPLACE avant l'emission. Sans cela, le bouton disparait
+     * sous le doigt de l'utilisateur clavier, le focus retombe sur le corps du
+     * document, et la navigation repart du haut de la page — le meme defaut que
+     * sur une liste d'etiquettes, et l'un des plus frequents.
+     */
+    protected fermer(): void;
+    /**
+     * Cible, dans l'ordre : le premier element focalisable qui SUIT la banniere
+     * dans le document, sinon le dernier qui la precede, sinon le conteneur s'il
+     * est focalisable par script.
+     *
+     * ⚠️ L'ordre du DOCUMENT, et non les descendants du voisin. La premiere
+     * version cherchait dans `nextElementSibling` : un bouton pose directement
+     * apres la banniere n'etait pas trouve, puisqu'il n'est pas son propre
+     * descendant, et le focus retombait sur le corps du document.
+     */
+    private deplacerLeFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StBanner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StBanner, "st-banner", never, { "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "titre": { "alias": "titre"; "required": false; "isSignal": true; }; "fermable": { "alias": "fermable"; "required": false; "isSignal": true; }; "libelleFermeture": { "alias": "libelleFermeture"; "required": false; "isSignal": true; }; }, { "ferme": "ferme"; }, never, ["*"], true, never>;
+}
+
+type TonDeMessage = TonSemantique;
+/**
+ * Message court attache a une zone precise : une aide sous un champ, une
+ * consequence sous un choix, une contrainte au-dessus d'un bouton.
+ *
+ * Distinct de `st-banner`, qui parle de la PAGE et se ferme.
+ *
+ * ⚠️ **Aucun role, aucune region vivante**, et c'est la difference qui compte.
+ * Un message en ligne est lu quand on atteint l'endroit auquel il se rattache ;
+ * en faire une region vivante le ferait annoncer hors contexte, et une
+ * vingtaine de champs produiraient vingt annonces a l'ouverture de l'ecran.
+ *
+ * ⚠️ Pour une erreur de SAISIE, ce composant ne suffit pas : le champ doit
+ * porter `aria-describedby` vers l'identifiant du message, sans quoi le lien
+ * entre les deux n'existe que visuellement. C'est `st-form-field` de la
+ * vague 3 qui posera ce lien.
+ */
+declare class StInlineMessage {
+    readonly ton: _angular_core.InputSignal<TonSemantique>;
+    /** Cible d'un `aria-describedby` pose par le champ decrit. */
+    readonly identifiant: _angular_core.InputSignal<string | null>;
+    protected readonly icone: _angular_core.Signal<"copie" | "boite-vide" | "cercle" | "cercle-coche" | "cercle-croix" | "cercle-info" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "coche" | "corbeille" | "croix" | "hors-ligne" | "lien-externe" | "menu" | "oeil" | "oeil-barre" | "plus" | "rafraichir" | "recherche" | "serveur" | "triangle-alerte" | "utilisateur">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StInlineMessage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StInlineMessage, "st-inline-message", never, { "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "identifiant": { "alias": "identifiant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Choix du theme : systeme, clair, sombre.
+ *
+ * ⚠️ **Trois etats, donc PAS un interrupteur.** `role="switch"` et
+ * `aria-pressed` sont binaires : poses sur un choix a trois valeurs, ils
+ * annoncent « active » ou « desactive » sans jamais dire lequel des trois est
+ * retenu. Un groupe de boutons radio dit exactement « Sombre, bouton radio,
+ * coche, 3 sur 3 ».
+ *
+ * ⚠️ **Composant de PRESENTATION.** Il n'injecte pas `StTheme` : `ui` ne depend
+ * pas de `@starterlib/core` (ADR 0003). La coquille le relie au noyau :
+ *
+ * ```html
+ * <st-theme-toggle [choix]="theme.choix()" (choisi)="theme.choisir($event)" />
+ * ```
+ */
+declare class StThemeToggle {
+    private readonly libelles;
+    readonly choix: _angular_core.InputSignal<ChoixDeTheme>;
+    /** Legende visible. Masquee par defaut, mais toujours lue : elle nomme le groupe. */
+    readonly legendeVisible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly choisi: _angular_core.OutputEmitterRef<ChoixDeTheme>;
+    /** Unique par instance : deux bascules sur la meme page partageraient leur groupe radio. */
+    protected readonly nom: string;
+    protected readonly legende: _angular_core.Signal<string>;
+    protected readonly options: _angular_core.Signal<{
+        valeur: ChoixDeTheme;
+        libelle: string;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StThemeToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StThemeToggle, "st-theme-toggle", never, { "choix": { "alias": "choix"; "required": true; "isSignal": true; }; "legendeVisible": { "alias": "legendeVisible"; "required": false; "isSignal": true; }; }, { "choisi": "choisi"; }, never, never, true, never>;
+}
+
+/**
+ * Choix de la langue de l'interface.
+ *
+ * ⚠️ **Chaque option porte son propre `lang`.** Sans lui, un lecteur d'ecran
+ * regle en francais lit « English » avec une voix francaise, et le mot devient
+ * incomprehensible pour la personne anglophone qui cherchait justement a
+ * l'entendre.
+ *
+ * ⚠️ **Composant de PRESENTATION.** Il n'injecte pas `StLangue` : `ui` ne depend
+ * pas de `@starterlib/core` (ADR 0003). La coquille le relie au noyau :
+ *
+ * ```html
+ * <st-lang-switch [courante]="langue.courante()" (choisie)="langue.changer($event)" />
+ * ```
+ */
+declare class StLangSwitch {
+    private readonly libelles;
+    readonly courante: _angular_core.InputSignal<Langue>;
+    readonly langues: _angular_core.InputSignal<readonly Langue[]>;
+    readonly legendeVisible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly choisie: _angular_core.OutputEmitterRef<Langue>;
+    protected readonly nom: string;
+    protected readonly legende: _angular_core.Signal<string>;
+    protected readonly options: _angular_core.Signal<{
+        code: Langue;
+        endonyme: string;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StLangSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StLangSwitch, "st-lang-switch", never, { "courante": { "alias": "courante"; "required": true; "isSignal": true; }; "langues": { "alias": "langues"; "required": false; "isSignal": true; }; "legendeVisible": { "alias": "legendeVisible"; "required": false; "isSignal": true; }; }, { "choisie": "choisie"; }, never, never, true, never>;
+}
+
+/**
+ * Bouton qui copie une valeur : reference de virement, adresse de depot, lien
+ * de partage.
+ *
+ * ⚠️ **Un element, et non un attribut pose sur un `<button>`.** La confirmation
+ * passe par une region vivante voisine du bouton ; posee DANS le bouton, elle
+ * entrerait dans son nom accessible, qui deviendrait « Copier Copie ».
+ *
+ * ⚠️ **Le libelle du bouton ne change pas** apres la copie, pour la raison que
+ * donne `st-code` : le lecteur d'ecran annoncerait un autre controle que celui
+ * qu'il a sous le doigt.
+ *
+ * ⚠️ **Jamais de secret.** Ce qui entre dans le presse-papiers est conserve par
+ * les gestionnaires d'historique et synchronise entre appareils : ni mot de
+ * passe, ni jeton, ni code a usage unique.
+ *
+ * Sans presse-papiers — hors contexte securise — le bouton n'est pas rendu : un
+ * controle qui ne peut rien faire ne doit pas s'offrir.
+ */
+declare class StCopyButton {
+    private readonly document;
+    private readonly libelles;
+    readonly valeur: _angular_core.InputSignal<string>;
+    /**
+     * `null` : le texte vient du dictionnaire de l'application.
+     *
+     * ⚠️ En icone seule, c'est le nom accessible du bouton : il doit dire CE qui
+     * est copie quand la page en offre plusieurs — « Copier l'IBAN » et non
+     * « Copier » repete cinq fois.
+     */
+    readonly libelle: _angular_core.InputSignal<string | null>;
+    readonly iconeSeule: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly messageDeConfirmation: _angular_core.InputSignal<string | null>;
+    readonly copie: _angular_core.OutputEmitterRef<string>;
+    protected readonly annonce: AnnonceLocale;
+    protected readonly disponible: boolean;
+    protected readonly libelleLu: _angular_core.Signal<string>;
+    protected copier(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StCopyButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StCopyButton, "st-copy-button", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "libelle": { "alias": "libelle"; "required": false; "isSignal": true; }; "iconeSeule": { "alias": "iconeSeule"; "required": false; "isSignal": true; }; "messageDeConfirmation": { "alias": "messageDeConfirmation"; "required": false; "isSignal": true; }; }, { "copie": "copie"; }, never, never, true, never>;
+}
+
+/**
+ * Compte a rebours avant un nouvel essai, pour une reponse `429` et son en-tete
+ * `Retry-After`.
+ *
+ * ```html
+ * @if (erreur.reessayerDans !== null) {
+ *   <st-timer [secondes]="erreur.reessayerDans" (termine)="reessayable.set(true)" />
+ * }
+ * ```
+ *
+ * ⚠️ **Il n'annonce PAS chaque seconde.** Une region vivante qui change toutes les
+ * secondes recouvre tout ce que le lecteur d'ecran essaie de dire, et empeche de
+ * lire le formulaire que la personne est justement en train de garder pret. Le
+ * decompte porte `role="timer"`, dont la valeur implicite est
+ * `aria-live="off"` : il se LIT quand on l'atteint. Seule la fin s'annonce.
+ *
+ * ⚠️ **Le temps restant se calcule contre l'horloge, pas en comptant les
+ * battements.** Un onglet en arriere-plan voit ses minuteries ralenties a une par
+ * minute : un compteur decremente a chaque battement afficherait encore
+ * « 45 s » a son retour, bien apres que le serveur a leve la limite.
+ */
+declare class StTimer {
+    private readonly libelles;
+    private readonly locale;
+    /** Duree d'attente en secondes, telle que `Retry-After` la donne. */
+    readonly secondes: _angular_core.InputSignal<number>;
+    readonly termine: _angular_core.OutputEmitterRef<void>;
+    protected readonly annonce: AnnonceLocale;
+    private readonly restant;
+    private echeance;
+    private minuterie;
+    protected readonly texte: _angular_core.Signal<string>;
+    constructor();
+    private demarrer;
+    private battre;
+    private arreter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StTimer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StTimer, "st-timer", never, { "secondes": { "alias": "secondes"; "required": true; "isSignal": true; }; }, { "termine": "termine"; }, never, never, true, never>;
+}
+
+/**
+ * Logo de l'organisation, en variante claire, sombre et monochrome.
+ *
+ * ⚠️ **Le texte alternatif est le NOM de l'organisation, jamais « logo ».** Un
+ * lecteur d'ecran annonce deja « image » : « Logo Banque Exemple » se lit
+ * « image, logo Banque Exemple ». Pose dans un lien vers l'accueil, ce nom
+ * devient celui du lien — il doit donc dire ou il mene.
+ *
+ * ⚠️ **Decoratif quand le nom est ecrit a cote.** Le repeter ferait lire
+ * « Banque Exemple Banque Exemple ».
+ *
+ * La variante suit le theme EFFECTIF pose par `StTheme` sur `<html data-theme>`,
+ * et non `prefers-color-scheme` : une personne qui a choisi le clair sur un
+ * systeme sombre doit voir le logo clair. Sous contraste force, la variante
+ * monochrome prend le relais — un logo en couleurs peut y disparaitre sur le
+ * fond impose.
+ *
+ * Les images viennent de la meme origine : la politique de securite du contenu
+ * n'autorise pas d'autre source d'image sans extension explicite cote BFF.
+ */
+declare class StLogo {
+    /** Nom de l'organisation : c'est le texte alternatif. */
+    readonly nom: _angular_core.InputSignal<string>;
+    readonly clair: _angular_core.InputSignal<string>;
+    /** `null` : la variante claire sert aussi sur fond sombre. */
+    readonly sombre: _angular_core.InputSignal<string | null>;
+    /** `null` : aucune variante dediee au contraste force. */
+    readonly monochrome: _angular_core.InputSignal<string | null>;
+    readonly decoratif: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hauteur: _angular_core.InputSignal<string>;
+    protected readonly texteAlternatif: _angular_core.Signal<string>;
+    protected readonly sourceSombre: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StLogo, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StLogo, "st-logo", never, { "nom": { "alias": "nom"; "required": true; "isSignal": true; }; "clair": { "alias": "clair"; "required": true; "isSignal": true; }; "sombre": { "alias": "sombre"; "required": false; "isSignal": true; }; "monochrome": { "alias": "monochrome"; "required": false; "isSignal": true; }; "decoratif": { "alias": "decoratif"; "required": false; "isSignal": true; }; "hauteur": { "alias": "hauteur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
  * Impose les cinq etats a un bloc qui consomme l'API, et centralise leur
  * annonce.
  *
+ * Deux usages. Le plus courant passe la ressource, et l'etat s'en deduit :
+ *
+ * ```html
+ * <st-state [ressource]="operations">
+ *   <ng-template [stSucces]="operations" let-page>…</ng-template>
+ *   <ng-template stErreur let-erreur><st-error … /></ng-template>
+ *   <ng-template stVide><st-empty … /></ng-template>
+ * </st-state>
+ * ```
+ *
+ * L'autre pose `[etat]` a la main, pour un bloc qui ne vient pas d'une
+ * ressource — une soumission de formulaire, par exemple.
+ *
+ * ⚠️ Un RECHARGEMENT garde le contenu affiche. Revenir a la silhouette a chaque
+ * changement de filtre fait clignoter la page entiere et perd la position de
+ * lecture ; seul le premier chargement n'a rien a montrer.
+ *
  * ⚠️ L'hote ne porte PAS `role="status"`, contrairement a ce qu'on attendrait :
  * un remplacement de contenu A L'INTERIEUR d'une region vivante fait relire
  * tout le sous-arbre par le lecteur d'ecran a chaque bascule d'etat. Seule une
- * petite zone masquee porte l'annonce, qui tient en quelques mots. L'hote se
- * contente d'`aria-busy`.
- *
- * Il fournit `REGION_VIVANTE_PARENTE` : les composants qu'il rend (indicateur
- * de chargement, erreur) detectent sa presence et se taisent, au lieu
- * d'annoncer une deuxieme fois le meme fait.
- */
-declare class StState {
-    readonly etat: _angular_core.InputSignal<EtatDeBloc>;
-    /** Le chemin nominal. Obligatoire : un bloc sans succes n'a pas de raison d'etre. */
-    readonly succes: _angular_core.InputSignal<TemplateRef<unknown>>;
-    readonly chargement: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    readonly erreur: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    readonly vide: _angular_core.InputSignal<TemplateRef<unknown> | null>;
-    readonly horsLigne: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+ * petite zone masquee porte l'annonce, qui tient en quelques mots.
+ */
+declare class StState<T> {
+    private readonly libelles;
+    /** La ressource dont l'etat se deduit. */
+    readonly ressource: _angular_core.InputSignal<Resource<T> | null>;
+    /** Etat pose a la main. Il prime sur la ressource quand les deux existent. */
+    readonly etat: _angular_core.InputSignal<EtatDeBloc | null>;
+    /** Ce qui compte comme « vide » : par defaut, une collection sans element. */
+    readonly estVide: _angular_core.InputSignal<(valeur: T) => boolean>;
     /** Silhouette par defaut du chargement. `null` : un indicateur tournant. */
     readonly squelette: _angular_core.InputSignal<VarianteDeSquelette | null>;
     readonly lignesDeSquelette: _angular_core.InputSignal<number>;
-    readonly annonces: _angular_core.InputSignal<Readonly<Record<EtatDeBloc, string>>>;
-    readonly annonce: _angular_core.Signal<string>;
+    /** `null` : les annonces viennent du dictionnaire de l'application. */
+    readonly annonces: _angular_core.InputSignal<Readonly<Record<EtatDeBloc, string>> | null>;
+    private readonly gabaritSucces;
+    private readonly gabaritErreur;
+    private readonly gabaritVide;
+    private readonly gabaritHorsLigne;
+    private readonly gabaritChargement;
+    private readonly instantane;
+    /**
+     * La derniere valeur connue, gardee pendant qu'une autre se charge.
+     *
+     * ⚠️ Necessaire, et pas seulement confortable : un changement de PARAMETRE
+     * n'est pas un `reload`. Angular traite le premier comme une nouvelle
+     * requete — statut « loading », valeur videe. Sans cette memoire, changer un
+     * filtre ou tourner une page ferait donc disparaitre le tableau, clignoter la
+     * page, et perdre la position de lecture. Une erreur, elle, ne garde rien :
+     * afficher des donnees perimees sous un message d'erreur serait mentir.
+     */
+    private readonly valeurRetenue;
+    /** Etat deduit de la ressource, valeur retenue comprise. */
+    private readonly etatDeLaRessource;
+    protected readonly etatEffectif: _angular_core.Signal<EtatDeBloc>;
+    /**
+     * Une valeur est affichee, et une autre arrive — par rappel explicite ou par
+     * changement de parametre.
+     */
+    protected readonly enRechargement: _angular_core.Signal<boolean>;
+    protected readonly enAttente: _angular_core.Signal<boolean>;
+    private readonly annoncesLues;
+    protected readonly annonce: _angular_core.Signal<string>;
+    /** Contexte passe au gabarit : la valeur en succes, l'erreur en erreur. */
+    protected readonly contexte: _angular_core.Signal<{
+        $implicit: unknown;
+    }>;
     /**
      * Les etats degrades n'ont pas de rendu par defaut : afficher un texte
      * generique a la place d'un vrai ecran vide ou d'une vraie erreur donnerait
      * l'illusion que les cinq etats sont traites. Il vaut mieux que le manque se
      * voie, en developpement.
      */
-    readonly gabaritDeLEtat: _angular_core.Signal<TemplateRef<unknown> | null>;
-    readonly montreLaSilhouetteParDefaut: _angular_core.Signal<boolean>;
+    protected readonly gabaritDeLEtat: _angular_core.Signal<TemplateRef<unknown> | null>;
+    private readonly chargementVisible;
+    /** La silhouette par defaut, une fois le delai anti-clignotement passe. */
+    protected readonly montreLaSilhouetteParDefaut: _angular_core.Signal<boolean>;
+    constructor();
     private signalerSiAbsent;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StState, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StState, "st-state", never, { "etat": { "alias": "etat"; "required": true; "isSignal": true; }; "succes": { "alias": "succes"; "required": true; "isSignal": true; }; "chargement": { "alias": "chargement"; "required": false; "isSignal": true; }; "erreur": { "alias": "erreur"; "required": false; "isSignal": true; }; "vide": { "alias": "vide"; "required": false; "isSignal": true; }; "horsLigne": { "alias": "horsLigne"; "required": false; "isSignal": true; }; "squelette": { "alias": "squelette"; "required": false; "isSignal": true; }; "lignesDeSquelette": { "alias": "lignesDeSquelette"; "required": false; "isSignal": true; }; "annonces": { "alias": "annonces"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StState<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StState<any>, "st-state", never, { "ressource": { "alias": "ressource"; "required": false; "isSignal": true; }; "etat": { "alias": "etat"; "required": false; "isSignal": true; }; "estVide": { "alias": "estVide"; "required": false; "isSignal": true; }; "squelette": { "alias": "squelette"; "required": false; "isSignal": true; }; "lignesDeSquelette": { "alias": "lignesDeSquelette"; "required": false; "isSignal": true; }; "annonces": { "alias": "annonces"; "required": false; "isSignal": true; }; }, {}, ["gabaritSucces", "gabaritErreur", "gabaritVide", "gabaritHorsLigne", "gabaritChargement"], never, true, never>;
+}
+
+/**
+ * Les gabarits des cinq etats, declares DANS `<st-state>`.
+ *
+ * ⚠️ Pourquoi des directives de contenu plutot que des entrees `TemplateRef` :
+ * un `<ng-template>` declare a l'exterieur du composant appartient a
+ * l'injecteur de l'endroit ou il est ECRIT, pas de celui qui le rend. Les
+ * fournisseurs de `st-state` — dont `REGION_VIVANTE_PARENTE`, qui fait taire
+ * les annonces en double — ne l'atteignaient donc pas, et l'erreur etait
+ * annoncee deux fois. Passer par le contenu rend la declaration a l'exterieur
+ * impossible : le defaut ne peut plus revenir.
+ */
+declare class StSucces<T> {
+    readonly gabarit: TemplateRef<{
+        $implicit: Exclude<T, undefined>;
+    }>;
+    /**
+     * La ressource n'est lue nulle part : elle porte le TYPE de la valeur, pour
+     * que `let-valeur` soit type dans le gabarit au lieu d'etre `unknown`.
+     */
+    readonly stSucces: _angular_core.InputSignal<Resource<T> | undefined>;
+    /**
+     * `Exclude<T, undefined>` : une ressource sans valeur initiale se type
+     * `T | undefined`, mais st-state ne rend ce gabarit QUE lorsqu'une valeur
+     * existe. Sans cela, chaque gabarit de succes devrait ecrire `page?.length`
+     * pour un cas qui ne se produit pas.
+     */
+    static ngTemplateContextGuard<T>(_directive: StSucces<T>, _contexte: unknown): _contexte is {
+        $implicit: Exclude<T, undefined>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StSucces<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StSucces<any>, "ng-template[stSucces]", never, { "stSucces": { "alias": "stSucces"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Erreur. Le contexte porte l'erreur elle-meme, pour l'afficher ou la traduire. */
+declare class StErreur {
+    readonly gabarit: TemplateRef<{
+        $implicit: unknown;
+    }>;
+    static ngTemplateContextGuard(_directive: StErreur, _contexte: unknown): _contexte is {
+        $implicit: unknown;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StErreur, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StErreur, "ng-template[stErreur]", never, {}, {}, never, never, true, never>;
+}
+declare class StVide {
+    readonly gabarit: TemplateRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StVide, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StVide, "ng-template[stVide]", never, {}, {}, never, never, true, never>;
+}
+declare class StHorsLigne {
+    readonly gabarit: TemplateRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StHorsLigne, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StHorsLigne, "ng-template[stHorsLigne]", never, {}, {}, never, never, true, never>;
+}
+/** Chargement sur mesure. Sans lui, `st-state` rend sa silhouette par defaut. */
+declare class StChargement {
+    readonly gabarit: TemplateRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StChargement, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StChargement, "ng-template[stChargement]", never, {}, {}, never, never, true, never>;
 }
+/** Toutes les directives de gabarit, a importer d'un coup. */
+declare const GABARITS_D_ETAT: readonly [typeof StSucces, typeof StErreur, typeof StVide, typeof StHorsLigne, typeof StChargement];
 
-export { CHEMIN_DU_SPRITE, ETATS_DE_BLOC, FUSEAU_PAR_DEFAUT, NOMS_DICONE, REGION_VIVANTE_PARENTE, StAvatar, StBadge, StButton, StButtonGroup, StCode, StCount, StDate, StEmpty, StError, StHeading, StIcon, StIconButton, StLink, StMasked, StMoney, StOfflineBanner, StProgress, StRelativeTime, StSkeleton, StSpinner, StState, StStatusPill, StTag, StText, fournirCheminDuSprite };
-export type { EtatDeBloc, FormatDeDate, GraisseDeTexte, NiveauDeTitre, NomDIcone, TailleDIcone, TailleDeBouton, TailleDeSpinner, TailleDeTitre, TonDIcone, TonDeBadge, TonDeProgression, TonDeSpinner, TonDeStatut, TypeMasque, VarianteDErreur, VarianteDeBouton, VarianteDeBoutonIcone, VarianteDeLien, VarianteDeSquelette, VarianteDeTexte };
+export { AnnonceLocale, CHEMIN_DU_SPRITE, FUSEAU_PAR_DEFAUT, GABARITS_D_ETAT, IDENTIFIANT_DU_CONTENU_PRINCIPAL, LIBELLES_EN, LIBELLES_FR, NOMS_DICONE, REGION_VIVANTE_PARENTE, ST_LIBELLES, ST_LOCALE, StAppShell, StAvatar, StBadge, StBanner, StBreadcrumb, StButton, StButtonGroup, StCard, StChargement, StCode, StCopyButton, StCount, StDate, StDivider, StEmpty, StErreur, StError, StHeader, StHeading, StHorsLigne, StIcon, StIconButton, StInlineMessage, StLangSwitch, StLink, StLogo, StMasked, StMoney, StOfflineBanner, StPageTitle, StProgress, StRelativeTime, StSection, StSkeleton, StSkipLink, StSpinner, StState, StStatusPill, StSucces, StTag, StText, StThemeToggle, StTimer, StVide, copierDansLePressePapiers, formaterDuree, fournirCheminDuSprite, pressePapiersDisponible, provideStarterUi };
+export type { ConfigurationUi, FormatDeDate, GraisseDeTexte, IssueDeCopie, LibellesUi, MaillonDeFil, NiveauDeTitre, NomDIcone, OrientationDeSeparateur, ReliefDeCarte, RembourrageDeCarte, TailleDIcone, TailleDeBouton, TailleDeSpinner, TailleDeTitre, TonDIcone, TonDeBadge, TonDeBanniere, TonDeMessage, TonDeProgression, TonDeSpinner, TonDeStatut, TypeMasque, VarianteDErreur, VarianteDeBouton, VarianteDeBoutonIcone, VarianteDeLien, VarianteDeSquelette, VarianteDeTexte };