@starterlib/ui 0.1.0

package/types/starterlib-ui.d.ts

@@ -0,0 +1,669 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { Montant } from '@starterlib/util';
+
+/**
+ * Chemin du sprite SVG des icones. Chaque SPA le remplace par son actif
+ * empreinte (`/assets/icones/sprite.<hash>.svg`) pour beneficier d'un cache
+ * immuable. Le defaut vise le chemin non empreinte, utilisable en
+ * developpement.
+ */
+declare const CHEMIN_DU_SPRITE: InjectionToken<string>;
+/**
+ * Marque la presence d'une region vivante possedee par un ancetre, en pratique
+ * la directive `stState`.
+ *
+ * Tout composant susceptible de porter un `role="status"` l'injecte en
+ * optionnel et **se tait** s'il en trouve un. Sans cela, un indicateur de
+ * chargement annonce dans une region qui annonce deja, et le lecteur d'ecran
+ * lit deux fois. Le defaut se voit seulement en usage reel, jamais en revue.
+ */
+declare const REGION_VIVANTE_PARENTE: InjectionToken<true>;
+/**
+ * Fuseau employe pour rendre les dates. Explicite parce qu'un rendu serveur et
+ * un rendu client qui ne s'accordent pas sur le fuseau produisent deux textes
+ * differents, et l'hydratation casse. Le SSR est ecarte en version 1, mais la
+ * compatibilite reste gardee.
+ */
+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.
+ */
+type EtatDeBloc = 'chargement' | 'erreur' | 'vide' | 'hors-ligne' | 'succes';
+declare const ETATS_DE_BLOC: readonly EtatDeBloc[];
+
+type TailleDIcone = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type TonDIcone = 'courant' | 'discret' | 'primaire' | 'succes' | 'avertissement' | 'danger';
+/**
+ * Icone tiree d'un sprite SVG servi en meme origine.
+ *
+ * Pourquoi un sprite et une reference externe plutot qu'une insertion : poser
+ * du SVG dans le document demanderait `innerHTML`, interdit dans ce depot, et
+ * une police d'icones rend un caractere arbitraire aux lecteurs d'ecran quand
+ * la police ne charge pas.
+ *
+ * Une icone est **decorative par defaut**. Regle de tri : si la retirer ne
+ * retire aucune information, elle est decorative. Une icone posee a cote d'un
+ * texte qui dit la meme chose l'est toujours.
+ */
+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 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>;
+    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>;
+}
+
+/**
+ * Noms du sprite, engendres depuis `assets/icones/sprite.svg`.
+ *
+ * Le type existe pour qu'une faute de frappe echoue a la compilation : une
+ * reference `use` vers un identifiant absent ne rend RIEN, sans erreur, et le
+ * defaut passe la revue.
+ */
+declare const NOMS_DICONE: readonly ["boite-vide", "cercle", "cercle-coche", "cercle-croix", "cercle-info", "chevron-bas", "chevron-droite", "chevron-gauche", "chevron-haut", "coche", "copie", "corbeille", "croix", "hors-ligne", "lien-externe", "menu", "oeil", "oeil-barre", "plus", "rafraichir", "recherche", "serveur", "triangle-alerte", "utilisateur"];
+type NomDIcone = (typeof NOMS_DICONE)[number];
+
+type VarianteDeTexte = 'corps' | 'corps-sm' | 'discret' | 'legende' | 'mono';
+type GraisseDeTexte = 'normale' | 'moyenne' | 'semi';
+/**
+ * Bloc de texte de l'echelle typographique.
+ *
+ * L'hote EST la boite : aucun enveloppeur interne, et jamais
+ * `display: contents`, qui retire l'element de l'arbre d'accessibilite dans
+ * plusieurs navigateurs.
+ */
+declare class StText {
+    readonly variante: _angular_core.InputSignal<VarianteDeTexte>;
+    readonly graisse: _angular_core.InputSignal<GraisseDeTexte>;
+    readonly enLigne: _angular_core.InputSignal<boolean>;
+    /**
+     * Nombre de lignes au-dela duquel le texte est coupe.
+     *
+     * ⚠️ A ne jamais employer sur un message d'erreur, un statut ou un libelle
+     * d'action : une information tronquee y devient fausse.
+     */
+    readonly tronquerA: _angular_core.InputSignal<number | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StText, "st-text", never, { "variante": { "alias": "variante"; "required": false; "isSignal": true; }; "graisse": { "alias": "graisse"; "required": false; "isSignal": true; }; "enLigne": { "alias": "enLigne"; "required": false; "isSignal": true; }; "tronquerA": { "alias": "tronquerA"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type NiveauDeTitre = 1 | 2 | 3 | 4 | 5 | 6;
+type TailleDeTitre = 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+/**
+ * Titre de section.
+ *
+ * `niveau` decrit la STRUCTURE du document, `taille` son APPARENCE. Les deux
+ * sont volontairement dissocies : c'est ce qui empeche de choisir un niveau 4
+ * parce qu'on le trouve plus petit, en cassant au passage la table des
+ * matieres que les lecteurs d'ecran construisent.
+ *
+ * L'hote porte `role="heading"` et `aria-level` plutot qu'une bascule sur six
+ * balises : cela demanderait six projections de contenu, fragiles, pour un
+ * resultat que les lecteurs d'ecran traitent de facon identique.
+ */
+declare class StHeading {
+    readonly niveau: _angular_core.InputSignal<NiveauDeTitre>;
+    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>;
+    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';
+/**
+ * Indicateur d'activite indeterminee.
+ *
+ * ⚠️ Deux pieges tenus ici, et aucun des deux ne se voit en revue :
+ *
+ * 1. Il n'emploie AUCUNE duree de l'echelle de jetons. Sous
+ *    `prefers-reduced-motion`, `--st-duree-*` passe a zero : un spinner cable
+ *    dessus se figerait, et l'ecran passerait pour bloque. Il declare sa propre
+ *    duree et bascule en pulsation d'opacite, qui n'a pas de composante
+ *    vestibulaire.
+ * 2. Il ne s'annonce que s'il n'est PAS deja dans une region vivante. Sinon le
+ *    lecteur d'ecran annonce deux fois le meme chargement.
+ */
+declare class StSpinner {
+    private readonly regionParente;
+    readonly taille: _angular_core.InputSignal<TailleDeSpinner>;
+    readonly ton: _angular_core.InputSignal<TonDeSpinner>;
+    readonly etiquette: _angular_core.InputSignal<string>;
+    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';
+/**
+ * Barre de progression, determinee ou indeterminee.
+ *
+ * ⚠️ Elle n'est JAMAIS placee dans une region vivante : `role="progressbar"`
+ * avec `aria-valuenow` est deja expose aux technologies d'assistance, et une
+ * region vivante par-dessus ferait annoncer chaque pourcent.
+ */
+declare class StProgress {
+    /** `null` : progression indeterminee. */
+    readonly valeur: _angular_core.InputSignal<number | null>;
+    readonly max: _angular_core.InputSignal<number>;
+    /** Obligatoire : une barre sans nom accessible n'apprend rien. */
+    readonly etiquette: _angular_core.InputSignal<string>;
+    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>;
+    /** Omis quand la progression est indeterminee : l'annoncer serait faux. */
+    readonly valeurAnnoncee: _angular_core.Signal<number | null>;
+    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>;
+}
+
+type VarianteDeSquelette = 'texte' | 'tableau' | 'carte';
+/**
+ * Silhouette du contenu en cours de chargement.
+ *
+ * Entierement masque aux technologies d'assistance : c'est `stState` qui
+ * annonce le chargement, une fois. Un squelette annonce ligne par ligne
+ * noierait le lecteur d'ecran.
+ *
+ * Il doit reproduire la BOITE du contenu reel, sinon l'arrivee des donnees
+ * fait sauter la mise en page.
+ */
+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[]>;
+    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';
+type TailleDeBouton = 'sm' | 'md' | 'lg';
+/**
+ * Bouton du socle, pose en ATTRIBUT sur un `<button>` natif.
+ *
+ * ⚠️ Pourquoi pas un element `<st-button>` qui enveloppe un bouton : l'enveloppe
+ * casse `type="submit"` (le bouton ne soumet plus le formulaire ancetre),
+ * l'attribut `form` ne porte plus, et l'hote devient un second arret de
+ * tabulation si quelqu'un lui pose un `tabindex`. Tout fonctionne en
+ * demonstration et casse au premier formulaire reel.
+ *
+ * ⚠️ Pendant le chargement, le bouton porte `aria-disabled` et NON `disabled` :
+ * l'attribut natif lui retire le focus, le lecteur d'ecran perd le controle
+ * qu'il avait sous le doigt et retombe sur le corps du document. Les clics
+ * sont interceptes par le composant.
+ */
+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>;
+    /**
+     * 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>;
+    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>;
+}
+
+type VarianteDeBoutonIcone = 'discret' | 'secondaire' | 'destructeur';
+/**
+ * Bouton reduit a une icone, pose en attribut sur un `<button>` natif.
+ *
+ * L'etiquette est OBLIGATOIRE : une icone seule n'a pas de nom accessible, et
+ * `title` n'en tient pas lieu — il n'apparait pas au toucher et n'est pas lu
+ * 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">;
+    /** 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>;
+    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>;
+}
+
+type VarianteDeLien = 'texte' | 'autonome' | 'discret';
+/**
+ * Lien, pose en attribut sur un `<a>` natif.
+ *
+ * ⚠️ Un `<a>` sans `href` est interdit : il n'est ni focalisable ni annonce
+ * comme lien. Une action qui ne navigue pas est un bouton.
+ *
+ * Les liens visites ne sont volontairement PAS distingues : sur une interface
+ * bancaire, la couleur de visite laisse fuir l'historique de navigation a
+ * quiconque regarde l'ecran.
+ */
+declare class StLink {
+    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>;
+    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>;
+}
+
+/**
+ * Regroupe des actions liees.
+ *
+ * ⚠️ `role="group"` et NON `role="toolbar"` : une barre d'outils exige un
+ * `tabindex` glissant et la navigation par fleches. Annoncer « barre d'outils »
+ * sans en fournir le comportement desoriente plus qu'un groupe simple. Le
+ * motif complet viendra avec les primitives d'`@angular/aria`.
+ */
+declare class StButtonGroup {
+    /** Nom du groupe : sans lui, le regroupement n'apprend rien a l'oral. */
+    readonly etiquette: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.InputSignal<"horizontale" | "verticale">;
+    /** Boutons jointifs, rayons fusionnes. */
+    readonly attache: _angular_core.InputSignal<boolean>;
+    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>;
+}
+
+/**
+ * Valeur technique courte et copiable : identifiant de trace, reference
+ * d'operation, code d'erreur.
+ *
+ * ⚠️ La confirmation de copie passe par une petite region vivante interne, et
+ * le LIBELLE DU BOUTON NE CHANGE PAS. Remplacer « Copier » par « Copie » ferait
+ * changer le nom accessible du controle que l'utilisateur a sous le doigt :
+ * le lecteur d'ecran annonce alors un autre bouton que celui qu'il croyait.
+ */
+declare class StCode {
+    private readonly document;
+    private readonly destruction;
+    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 copie: _angular_core.OutputEmitterRef<string>;
+    private readonly confirmation;
+    private minuterie;
+    readonly texteDeConfirmation: _angular_core.Signal<string>;
+    /**
+     * 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 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>;
+}
+
+type TypeMasque = 'iban' | 'carte' | 'telephone';
+/**
+ * Identifiant sensible, masque par defaut.
+ *
+ * ⚠️ La valeur masquee porte un `aria-label` en toutes lettres (« IBAN se
+ * terminant par 2606 ») : plusieurs lecteurs d'ecran epellent une suite de
+ * puces caractere par caractere, ce qui est a la fois illisible et interminable.
+ *
+ * La revelation est un EVENEMENT METIER : elle se journalise cote appelant par
+ * la sortie `revelation`. La valeur revelee, elle, ne part jamais dans un
+ * journal.
+ */
+declare class StMasked {
+    private readonly destruction;
+    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 dureeDeRevelationEnSecondes: _angular_core.InputSignal<number>;
+    readonly libelleAfficher: _angular_core.InputSignal<string>;
+    readonly libelleMasquer: _angular_core.InputSignal<string>;
+    readonly revelation: _angular_core.OutputEmitterRef<{
+        type: TypeMasque;
+    }>;
+    private readonly annonce;
+    readonly texteDAnnonce: _angular_core.Signal<string>;
+    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>;
+    private valeurLisible;
+    protected basculer(): void;
+    private masquer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StMasked, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StMasked, "st-masked", never, { "valeur": { "alias": "valeur"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "revele": { "alias": "revele"; "required": false; "isSignal": true; }; "revelationAutorisee": { "alias": "revelationAutorisee"; "required": false; "isSignal": true; }; "dureeDeRevelationEnSecondes": { "alias": "dureeDeRevelationEnSecondes"; "required": false; "isSignal": true; }; "libelleAfficher": { "alias": "libelleAfficher"; "required": false; "isSignal": true; }; "libelleMasquer": { "alias": "libelleMasquer"; "required": false; "isSignal": true; }; }, { "revele": "reveleChange"; "revelation": "revelation"; }, never, never, true, never>;
+}
+
+/**
+ * Somme d'argent.
+ *
+ * Le montant entre sous forme d'unites mineures entieres : un nombre a virgule
+ * flottante ne represente pas exactement 0,10 EUR, et les erreurs s'accumulent.
+ * La conversion n'a lieu qu'a l'instant du rendu.
+ *
+ * ⚠️ Le signe negatif est TOUJOURS rendu en texte. La couleur ne fait que le
+ * renforcer : un daltonien, une impression en noir et blanc ou un theme a fort
+ * contraste ne doivent jamais transformer un debit en credit.
+ */
+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 taille: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl">;
+    readonly signe: _angular_core.Signal<"negatif" | "positif" | "nul">;
+    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>;
+}
+
+type FormatDeDate = 'court' | 'long' | 'date-heure' | 'heure';
+/**
+ * Date rendue dans la locale et le fuseau de l'application.
+ *
+ * ⚠️ La locale et le fuseau sont EXPLICITES, jamais deduits de l'environnement
+ * d'execution. Un rendu serveur et un rendu navigateur qui ne s'accordent pas
+ * produisent deux textes differents, et l'hydratation casse. Le rendu serveur
+ * est ecarte en version 1, mais la compatibilite reste gardee a cout nul.
+ *
+ * Le format court garde un nom accessible en toutes lettres : « 12/09/26 » est
+ * ambigu a l'oral, et l'ordre jour-mois n'est pas universel.
+ */
+declare class StDate {
+    private readonly locale;
+    private readonly fuseauParDefaut;
+    readonly valeur: _angular_core.InputSignal<string | Date>;
+    readonly format: _angular_core.InputSignal<FormatDeDate>;
+    readonly fuseau: _angular_core.InputSignal<string | null>;
+    private readonly date;
+    readonly estValide: _angular_core.Signal<boolean>;
+    readonly iso: _angular_core.Signal<string | null>;
+    readonly texte: _angular_core.Signal<string>;
+    /** Forme longue, lue par les technologies d'assistance. */
+    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>;
+}
+
+/**
+ * Temps ecoule, exprime relativement (« il y a 5 minutes »).
+ *
+ * ⚠️ Ce composant ne doit JAMAIS etre place dans une region vivante : son texte
+ * se reecrit tout seul, et une region vivante le ferait annoncer en boucle.
+ * Son nom accessible porte la date absolue, qui elle ne bouge pas.
+ *
+ * La cadence de rafraichissement s'adapte : rafraichir chaque seconde une date
+ * vieille de trois jours reveille l'onglet pour rien.
+ */
+declare class StRelativeTime {
+    private readonly locale;
+    private readonly fuseau;
+    readonly valeur: _angular_core.InputSignal<string | Date>;
+    readonly rafraichir: _angular_core.InputSignal<boolean>;
+    /** 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>;
+    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>;
+}
+
+/**
+ * Nombre dans le flux du texte.
+ *
+ * Distinct de `st-badge`, qui est une pastille superposee a un autre element.
+ *
+ * ⚠️ Quand la valeur est abregee (« 1,2 k »), le nom accessible porte le nombre
+ * COMPLET : l'abreviation est une commodite visuelle, pas une perte
+ * d'information pour qui ecoute la page.
+ */
+declare class StCount {
+    private readonly locale;
+    readonly valeur: _angular_core.InputSignal<number>;
+    readonly ton: _angular_core.InputSignal<"courant" | "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>;
+    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';
+/**
+ * Pastille de statut.
+ *
+ * ⚠️ Le libelle ET l'icone sont OBLIGATOIRES, et l'icone doit differer par sa
+ * FORME d'un ton a l'autre (coche, triangle, croix, cercle). Un statut porte
+ * par la seule couleur est illisible pour une personne daltonienne, a
+ * l'impression, et sous un theme a fort contraste.
+ *
+ * ⚠️ Aucun role ARIA, malgre le nom du composant : `role="status"` en ferait
+ * une region vivante, et une liste de vingt lignes ferait annoncer vingt
+ * statuts a chaque rendu.
+ */
+declare class StStatusPill {
+    /** Code machine du statut : sert aux tests et aux selecteurs, jamais a l'affichage. */
+    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>;
+    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';
+/**
+ * Pastille de comptage superposee a un autre element.
+ *
+ * ⚠️ Elle est TOUJOURS `aria-hidden`. Un « 5 » flottant, lu hors contexte,
+ * n'apprend rien. Le compte doit entrer dans le nom accessible de l'element
+ * porteur : « Notifications, 5 non lues », compose par l'appelant.
+ *
+ * L'element porteur doit declarer la classe `st-badge-ancre`.
+ */
+declare class StBadge {
+    readonly valeur: _angular_core.InputSignal<string | number | null>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly ton: _angular_core.InputSignal<TonDeBadge>;
+    /** Point seul, sans chiffre : signale une nouveaute sans la quantifier. */
+    readonly point: _angular_core.InputSignal<boolean>;
+    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>;
+}
+
+/**
+ * Etiquette, eventuellement retirable.
+ *
+ * ⚠️ Le retrait DEPLACE LE FOCUS avant de s'annoncer. 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. C'est l'un
+ * des defauts d'accessibilite les plus frequents des listes d'etiquettes.
+ */
+declare class StTag {
+    private readonly element;
+    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 supprime: _angular_core.OutputEmitterRef<void>;
+    readonly libelleDeSuppression: _angular_core.Signal<string>;
+    protected auRetrait(): void;
+    /**
+     * Cible, dans l'ordre : le bouton de l'etiquette suivante, celui de la
+     * precedente, puis le conteneur s'il est focalisable par script.
+     */
+    private deplacerLeFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StTag, "st-tag", never, { "libelle": { "alias": "libelle"; "required": true; "isSignal": true; }; "supprimable": { "alias": "supprimable"; "required": false; "isSignal": true; }; "ton": { "alias": "ton"; "required": false; "isSignal": true; }; "prefixeDeSuppression": { "alias": "prefixeDeSuppression"; "required": false; "isSignal": true; }; }, { "supprime": "supprime"; }, never, never, true, never>;
+}
+
+/**
+ * Representation d'une personne.
+ *
+ * ⚠️ Aucune couleur derivee d'un hachage du nom. Une palette engendree a
+ * l'execution n'offre AUCUNE garantie de contraste, ce qui annulerait la
+ * verification des paires semantiques : un nom malchanceux produirait un
+ * avatar illisible, et aucun test ne le verrait.
+ */
+declare class StAvatar {
+    readonly nom: _angular_core.InputSignal<string>;
+    readonly sourceImage: _angular_core.InputSignal<string | null>;
+    readonly taille: _angular_core.InputSignal<"xs" | "sm" | "md" | "lg">;
+    readonly forme: _angular_core.InputSignal<"cercle" | "carre">;
+    /**
+     * `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>;
+    private readonly imageEchouee;
+    readonly afficheLImage: _angular_core.Signal<boolean>;
+    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 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>;
+}
+
+/**
+ * Etat vide : il n'y a rien a montrer, et ce n'est pas une erreur.
+ *
+ * Le niveau du titre est fourni par l'APPELANT : un bloc vide place au milieu
+ * d'une page ne connait pas sa profondeur dans le document, et un niveau devine
+ * casserait la table des matieres que les lecteurs d'ecran construisent.
+ */
+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 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>;
+}
+
+type VarianteDErreur = 'hors-ligne' | 'serveur' | 'client';
+/**
+ * Etat d'erreur d'un bloc.
+ *
+ * ⚠️ `titre` et `message` sont deja TRADUITS par l'appelant. Le socle backend
+ * n'emet jamais de phrase destinee a l'utilisateur : il rend un code stable, et
+ * la traduction appartient au client. Le `code` est affiche comme donnee
+ * technique, jamais comme explication.
+ *
+ * ⚠️ `role="alert"` seulement hors d'une region vivante existante : c'est le
+ * seul etat assertif du systeme, et il ne doit pas doubler l'annonce de
+ * `st-state`.
+ */
+declare class StError {
+    private readonly regionParente;
+    readonly variante: _angular_core.InputSignal<VarianteDErreur>;
+    /** Code machine stable, tel que rendu par le backend. */
+    readonly code: _angular_core.InputSignal<string>;
+    readonly titre: _angular_core.InputSignal<string>;
+    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 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>;
+    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>;
+}
+
+/**
+ * Banniere de perte de connexion.
+ *
+ * ⚠️ `role="status"` (poli) et NON `role="alert"`. Une perte de reseau n'est
+ * pas actionnable dans la seconde ; une annonce assertive interromprait une
+ * saisie en cours. La banniere est persistante, elle sera lue.
+ *
+ * ⚠️ Aucun bouton de fermeture : l'utilisateur ne peut pas fermer un fait.
+ *
+ * ⚠️ `sticky` et non `fixed` : a 200 % d'echelle, un element fixe recouvre le
+ * contenu qu'il annonce.
+ */
+declare class StOfflineBanner {
+    readonly message: _angular_core.InputSignal<string>;
+    readonly libelleRejeu: _angular_core.InputSignal<string | null>;
+    readonly rejeuEnCours: _angular_core.InputSignal<boolean>;
+    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>;
+}
+
+/**
+ * Impose les cinq etats a un bloc qui consomme l'API, et centralise leur
+ * annonce.
+ *
+ * ⚠️ 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>;
+    /** 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>;
+    /**
+     * 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>;
+    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>;
+}
+
+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 };
+export type { EtatDeBloc, FormatDeDate, GraisseDeTexte, NiveauDeTitre, NomDIcone, TailleDIcone, TailleDeBouton, TailleDeSpinner, TailleDeTitre, TonDIcone, TonDeBadge, TonDeProgression, TonDeSpinner, TonDeStatut, TypeMasque, VarianteDErreur, VarianteDeBouton, VarianteDeBoutonIcone, VarianteDeLien, VarianteDeSquelette, VarianteDeTexte };