@starterlib/ui 0.7.2 → 0.9.0

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

@@ -0,0 +1,1489 @@
+import { AnnonceLocale, Icone, TailleDAvatar, TailleDIconeFixe, TonDAvatar } from "@starterlib/ui";
+import * as i0 from "@angular/core";
+import { Montant, Ton, TonSemantique } from "@starterlib/util";
+export type TypeMasque = 'iban' | 'carte' | 'telephone' | 'reference';
+/**
+ * `ligne` : dans le flux d'une phrase ou d'une cellule. `tuile` : la tuile de la planche 2
+ * (libelle en surtitre, valeur en groupes, bouton a droite ; revelee, la valeur prend toute la
+ * largeur et le decompte se pose a cote du libelle).
+ */
+export type VarianteDeMasque = 'ligne' | 'tuile';
+/** `sm` : 14 px, la valeur d'un seul tenant ; `lg` : 18 px 600, en groupes espaces (planche 2). */
+export type TailleDeMasque = 'sm' | 'lg';
+/** Un groupe de la valeur : quatre caracteres (ou une paire, un indicatif), masque ou lisible. */
+interface Groupe {
+  readonly texte: string;
+  readonly points: boolean;
+  readonly extremite: boolean;
+}
+/**
+ * Identifiant sensible, masque par defaut.
+ *
+ * **La valeur complete n'a rien a faire dans le navigateur** hors de la voie autorisee :
+ * `valeur` accepte la forme DEJA MASQUEE par le serveur (« FR76 •••• •••• 0189 », voie
+ * nominale des listes). La revelation passe par `charger`, que l'appelant branche sur un appel
+ * serveur AUDITE ; la valeur complete n'arrive qu'a ce moment, ne vit que le temps de la
+ * revelation, et quitte le composant au remasquage. Sans `charger`, aucun bouton.
+ *
+ * ⚠️ Le bouton garde un NOM FIXE (« Afficher l'IBAN ») et bascule `aria-pressed` (APG) : un
+ * nom qui change sous le doigt fait croire a un autre bouton. La revelation est annoncee, le
+ * remasquage aussi, et l'echec d'un chargement laisse le masque et le dit.
+ *
+ * ⚠️ Remasquage a l'expiration (`rythme.tenue.revelation`, 30 s, bornee de 5 a 120 s), quand
+ * l'onglet est masque et quand la fenetre perd le focus : une valeur revelee puis oubliee a
+ * l'ecran est lisible par quiconque passe derriere. A l'impression, la valeur est TOUJOURS
+ * masquee.
+ *
+ * ⚠️ Une revelation appartient a UN enregistrement. Une autre `valeur`, une autre voie
+ * (`charger`) ou un autre `type` remet le composant au masque : le routeur reutilise le composant
+ * de `/comptes/1` a `/comptes/2`, un tri recycle une ligne, et l'IBAN revele du premier restait
+ * affiche et lu sous l'en-tete du second. Un chargement qui aboutit pour un enregistrement quitte
+ * (ou apres la destruction) est jete. `charger` doit donc etre une reference STABLE (un champ de
+ * la classe), jamais une fonction recreee a chaque detection.
+ *
+ * La valeur masquee porte un nom en toutes lettres (« IBAN se terminant par 2606 ») : plusieurs
+ * lecteurs d'ecran epellent une suite de puces caractere par caractere.
+ *
+ * ```html
+ * <st-masked [valeur]="compte.ibanMasque" [charger]="revelerLIban" variante="tuile" taille="lg"
+ *   libelle="IBAN" afficherLeDecompte (revelation)="journaliser($event)" />
+ * ```
+ */
+export declare class StMasked {
+  private readonly libelles;
+  private readonly document;
+  /** La valeur, complete ou deja masquee par le serveur (« •••• 6467 »). */
+  readonly valeur: import("@angular/core").InputSignal<string>;
+  readonly type: import("@angular/core").InputSignal<TypeMasque>;
+  /**
+   * La voie autorisee de revelation : un appel serveur audite qui rend la valeur complete (une
+   * chaine si l'appelant la detient deja, pour la reveler sans attendre). Le bouton n'existe que
+   * si elle est fournie.
+   */
+  readonly charger: import("@angular/core").InputSignal<(() => string | Promise<string>) | null>;
+  /** Remasquage automatique, borne de 5 a 120 s (defaut `rythme.tenue.revelation`, 30 s). */
+  readonly dureeDeRevelationEnSecondes: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Surtitre visible de la tuile (« IBAN du compte courant »). */
+  readonly libelle: import("@angular/core").InputSignal<string | null>;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeMasque>;
+  readonly taille: import("@angular/core").InputSignal<TailleDeMasque>;
+  /** Montre le decompte du remasquage (« Masque dans 27s ») pendant la revelation. */
+  readonly afficherLeDecompte: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Nom FIXE du bouton. `null` : « Afficher l'IBAN », « Afficher le numero de carte »... */
+  readonly libelleAfficher: import("@angular/core").InputSignal<string | null>;
+  /** Revelation reussie : un EVENEMENT METIER, a journaliser. La valeur n'y figure jamais. */
+  readonly revelation: import("@angular/core").OutputEmitterRef<{
+    type: TypeMasque;
+  }>;
+  /** L'etat reel, en sortie seule : l'appelant ne peut pas reveler sans passer par la voie. */
+  readonly reveleChange: import("@angular/core").OutputEmitterRef<boolean>;
+  /**
+   * ⚠️ 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;
+  /** Ce qui est montre ; un autre enregistrement en est un autre (egalite champ a champ). */
+  private readonly enregistrement;
+  /**
+   * ⚠️ Derives de l'enregistrement : a son changement, l'etat repart MASQUE et la valeur complete
+   * est oubliee, sans attendre un evenement. Un signal simple les gardait d'un enregistrement a
+   * l'autre (revue E8).
+   */
+  private readonly etat;
+  private readonly valeurComplete;
+  private minuterie;
+  /** Numero de la demande en cours : le resultat d'une demande perimee est jete. */
+  private demande;
+  /** `reveleChange(true)` a ete emis sans son `false` : le remasquage le doit a l'appelant. */
+  private reveleSignale;
+  protected readonly revele: import("@angular/core").Signal<boolean>;
+  protected readonly enChargement: import("@angular/core").Signal<boolean>;
+  /** Une valeur qui contient des puces a ete masquee par le serveur : rien a reveler ici. */
+  private readonly dejaMasquee;
+  protected readonly revelationPossible: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected readonly valeurMasquee: import("@angular/core").Signal<string>;
+  private readonly valeurLisible;
+  protected readonly valeurAffichee: import("@angular/core").Signal<string>;
+  /**
+   * La valeur en groupes (taille `lg`) : les blocs de l'ecriture, l'indicatif d'un telephone
+   * et son premier chiffre ensemble (« +33 6 •• •• •• 89 », planche 2). Revelee, la tete et
+   * la fin sont appuyees : c'est ce qu'on compare a son releve.
+   */
+  protected readonly groupes: import("@angular/core").Signal<readonly Groupe[]>;
+  /**
+   * La fin lisible d'une valeur masquee : ce qui suit la derniere puce (« 89 » d'un telephone
+   * masque par paires), ou les quatre derniers caracteres d'une valeur complete. `quatreDerniers`
+   * le fait lui-meme depuis le lot 179.
+   */
+  private readonly finLisible;
+  private readonly nature;
+  /**
+   * 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: import("@angular/core").Signal<string>;
+  protected readonly libelleDuBouton: import("@angular/core").Signal<string>;
+  protected basculer(): void;
+  private reveler;
+  private montrer;
+  private masquer;
+  /** L'enregistrement a change : l'ancienne revelation n'a plus de suite. */
+  private oublierLaRevelation;
+  private arreterLaMinuterie;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMasked, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMasked, "st-masked", never, {
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "charger": {
+      "alias": "charger";
+      "required": false;
+      "isSignal": true;
+    };
+    "dureeDeRevelationEnSecondes": {
+      "alias": "dureeDeRevelationEnSecondes";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelle": {
+      "alias": "libelle";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "taille": {
+      "alias": "taille";
+      "required": false;
+      "isSignal": true;
+    };
+    "afficherLeDecompte": {
+      "alias": "afficherLeDecompte";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleAfficher": {
+      "alias": "libelleAfficher";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "revelation": "revelation";
+    "reveleChange": "reveleChange";
+  }, never, ["[fin]", "*"], true, never>;
+}
+/**
+ * Tailles de la planche 2 (D18) : `sm` 14, `md` le corps du texte en 500, `lg` 18/24, `xl`
+ * 20/28, `2xl` 24/32, `hero` 40/48. Au-dela de `md`, un montant est un chiffre cle : graisse
+ * 600 et approche negative de sa taille. Sans taille, le montant prend TOUTE la typographie
+ * de son contexte : la valeur d'un `st-stat`, une cellule, une phrase.
+ */
+export type TailleDeMontant = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'hero';
+/**
+ * Couleur choisie par l'appelant : `discret` pour un solde nul ou clos, `primaire` pour la
+ * ligne choisie d'un tableau, `succes` et `danger` pour un statut de ligne (execute, rejete).
+ * ⚠️ Un statut, jamais un sens : un debit n'est pas une erreur (D30). Le sens d'une
+ * VARIATION se dit par `variation`, qui lit `positif` et `negatif`.
+ */
+export type TonDeMontant = Extract<Ton, 'neutre' | 'discret' | 'primaire' | 'succes' | 'danger'>;
+/** `mono` : colonne de chasse fixe des tableaux (planche 4, D19). */
+export type PoliceDeMontant = 'base' | 'mono';
+/** `fin` : cellule numerique, les virgules s'alignent en colonne. */
+export type AlignementDeMontant = 'debut' | 'fin';
+/**
+ * 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, par Intl, a la place que la
+ * locale lui donne, et en vrai signe moins (U+2212). 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. Et parce que
+ * certains lecteurs d'ecran taisent U+2212 a leur niveau de ponctuation par
+ * defaut, un montant negatif se LIT « moins 1 250,00 € » : le texte visible est
+ * alors masque aux technologies d'assistance, dans ce seul cas.
+ *
+ * ⚠️ `masque` rend « ••••,•• € » et ne met la valeur NULLE PART dans le document :
+ * ni dans le texte, ni dans l'attribut `value`, ni dans un texte lu, ni son SIGNE (aucun
+ * `data-signe`, aucune couleur de variation : un credit en vert dirait qui est a decouvert).
+ * Une vue publique ou une mise en veille ne se contourne pas par l'inspecteur. Le `ton` de
+ * l'appelant reste : c'est un statut de ligne, pas un signe. Tout l'ecran se masque d'un geste
+ * par `ST_MONTANTS_MASQUES` (`st-privacy-toggle`, lot 256).
+ *
+ * ⚠️ La forme masquee a la MEME largeur quel que soit le montant (quatre points pour la partie
+ * entiere, chasse fixe) : une largeur qui suivrait le montant dirait son ordre de grandeur a qui
+ * regarde l'ecran (D136).
+ *
+ * ```html
+ * <st-money [valeur]="solde" taille="hero" />
+ * <st-money [valeur]="operation.montant" variation signeExplicite />
+ * ```
+ */
+export declare class StMoney {
+  private readonly locale;
+  private readonly libelles;
+  private readonly montantsMasques;
+  readonly valeur: import("@angular/core").InputSignal<Montant>;
+  readonly signeExplicite: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly sansDevise: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `null` : corps, graisse et interlettrage du texte qui entoure le montant. */
+  readonly taille: import("@angular/core").InputSignal<TailleDeMontant | null>;
+  /**
+   * Le montant est un CREDIT ou un DEBIT : il lit `--st-couleur-positif` ou
+   * `--st-couleur-negatif` (qui vaut l'encre du texte tant qu'une charte ne le change
+   * pas). Sans elle, un solde negatif reste dans l'encre du texte.
+   */
+  readonly variation: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `null` : l'encre du texte, ou celle de la variation. Prime sur la variation. */
+  readonly ton: import("@angular/core").InputSignal<TonDeMontant | null>;
+  readonly police: import("@angular/core").InputSignal<PoliceDeMontant>;
+  /** `null` : l'alignement du conteneur (une cellule numerique aligne deja a la fin). */
+  readonly alignement: import("@angular/core").InputSignal<AlignementDeMontant | null>;
+  /** Veille, vue publique : les chiffres ne sont pas rendus, seulement leur forme. */
+  readonly masque: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Masque par l'entree, ou par l'ecran entier (`ST_MONTANTS_MASQUES`). */
+  protected readonly masqueLu: import("@angular/core").Signal<boolean>;
+  protected readonly signe: import("@angular/core").Signal<"negatif" | "positif" | "nul">;
+  private readonly options;
+  protected readonly texte: import("@angular/core").Signal<string>;
+  /**
+   * Valeur lisible par machine de `<data>` : unites mineures et code ISO de la devise
+   * (« -125000 EUR »). Ni arrondie, ni convertie : ce que l'API a transmis.
+   */
+  protected readonly valeurMachine: import("@angular/core").Signal<string>;
+  /** « moins 1 250,00 € » : le montant absolu, precede du mot du dictionnaire. */
+  protected readonly texteLu: import("@angular/core").Signal<string>;
+  /**
+   * La FORME du montant sans ses chiffres : « ••••,•• € », « $••••.•• ». Separateur
+   * decimal et devise de la locale, une decimale masquee par decimale de la devise ;
+   * ni le signe ni l'ordre de grandeur (groupes) ne sont rendus, ils trahiraient la valeur.
+   */
+  protected readonly texteMasque: import("@angular/core").Signal<string>;
+  protected readonly libelleMasque: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMoney, never>;
+  static ɵcmp: i0.ɵɵ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;
+    };
+    "variation": {
+      "alias": "variation";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "police": {
+      "alias": "police";
+      "required": false;
+      "isSignal": true;
+    };
+    "alignement": {
+      "alias": "alignement";
+      "required": false;
+      "isSignal": true;
+    };
+    "masque": {
+      "alias": "masque";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * `court` 17/09/2026, `long` 17 septembre 2026, `moyen` 17 sept. 2026, 09:30 (planche 2),
+ * `date-heure` 17/09/2026 09:30, `heure` 09:30.
+ */
+export type FormatDeDate = 'court' | 'long' | 'moyen' | 'date-heure' | 'heure';
+/**
+ * `valeur` : une date lue pour elle-meme (cellule, liste de description). `meta` : une date
+ * dans une phrase attenuee (« Echeance au 30/09/2026 », planche 2) — la date seule y est
+ * appuyee (600, encre du texte), et ses chiffres sont ceux du texte courant.
+ */
+export type VarianteDeDate = 'valeur' | 'meta';
+/**
+ * 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.
+ *
+ * ⚠️ Ce qui se lit est ce qui se voit : le texte n'est masque aux technologies
+ * d'assistance que si un equivalent est lu a sa place. Le format court se lit en
+ * toutes lettres (« 12/09/26 » est ambigu a l'oral, et l'ordre jour-mois n'est pas
+ * universel) ; les autres se lisent tels qu'affiches. Une date absente ou illisible
+ * rend « — », lu « Date inconnue », et non un hote vide.
+ *
+ * ⚠️ Une heure SANS decalage (« 2026-09-17T09:30 ») est une heure de mur : elle se
+ * lit dans le fuseau de rendu. `new Date()` la lisait dans le fuseau du NAVIGATEUR,
+ * puis la rendait dans celui de l'application : l'heure changeait en voyage.
+ *
+ * Chiffres : alignes (tabulaires) quand la date est une valeur chiffree (`court`,
+ * `date-heure`, `heure`), ceux du texte quand elle s'ecrit en mots (`long`, `moyen`)
+ * ou dans une phrase (`meta`) — la planche 2 les compose ainsi, et une colonne de
+ * dates ne s'ecrit pas en toutes lettres.
+ */
+export declare class StDate {
+  private readonly locale;
+  private readonly libelles;
+  private readonly fuseauParDefaut;
+  /** `null`, `''` ou une chaine illisible : « — », lu « Date inconnue ». */
+  readonly valeur: import("@angular/core").InputSignal<string | Date | null>;
+  readonly format: import("@angular/core").InputSignal<FormatDeDate>;
+  readonly fuseau: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Affiche le fuseau apres l'heure, « (Europe/Paris) » (planche 2). A poser des que le
+   * fuseau differe de celui de l'application : une heure sans fuseau ment a qui voyage.
+   * Sans effet sur une date sans heure.
+   */
+  readonly afficherLeFuseau: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeDate>;
+  /**
+   * 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;
+  /**
+   * 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;
+  private readonly date;
+  protected readonly estValide: import("@angular/core").Signal<boolean>;
+  constructor();
+  /**
+   * 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: import("@angular/core").Signal<string | null>;
+  /** Une date sans heure ne peut pas en afficher une. */
+  private readonly optionsDeFormat;
+  protected readonly texte: import("@angular/core").Signal<string>;
+  /** « (Europe/Paris) » : le fuseau tel que l'application le nomme, apres l'heure. */
+  protected readonly fuseauAffiche: import("@angular/core").Signal<string | null>;
+  /** Forme longue du format court, lue par les technologies d'assistance a sa place. */
+  protected readonly texteAccessible: import("@angular/core").Signal<string | null>;
+  protected readonly dateInconnue: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDate, never>;
+  static ɵcmp: i0.ɵɵ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;
+    };
+    "afficherLeFuseau": {
+      "alias": "afficherLeFuseau";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * `neutre` : l'encre du texte (planche 2, « il y a 5 minutes ») ; `discret` : un horodatage
+ * secondaire ; `primaire` : ce qui vient d'arriver, appuye (« a l'instant », 600).
+ */
+export type TonDeTempsRelatif = Extract<Ton, 'neutre' | 'discret' | 'primaire'>;
+/**
+ * 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.
+ *
+ * `avecAbsolu` montre aussi la date absolue, « il y a 2 h (17 sept. 2026, 07:30) » : pour un
+ * journal d'audit, ou le relatif seul est ambigu. Le relatif passe alors a sa forme courte, et
+ * les deux se lisent tels qu'affiches — plus de texte masque qui dirait autre chose que l'ecran.
+ *
+ * La cadence de rafraichissement s'adapte : rafraichir chaque seconde une date
+ * vieille de trois jours reveille l'onglet pour rien. Et un onglet MASQUE ne
+ * rafraichit rien : le texte est recalcule a son retour.
+ */
+export declare class StRelativeTime {
+  private readonly locale;
+  private readonly libelles;
+  private readonly fuseau;
+  private readonly document;
+  readonly valeur: import("@angular/core").InputSignal<string | Date>;
+  readonly rafraichir: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly ton: import("@angular/core").InputSignal<TonDeTempsRelatif>;
+  readonly avecAbsolu: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Au-dela de ce nombre de jours, la date absolue est plus parlante. */
+  readonly seuilAbsoluEnJours: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  private readonly destruction;
+  private readonly maintenant;
+  constructor();
+  /**
+   * L'instant de la valeur. Une chaine se lit par `lireInstant`, comme dans `st-date` : `new Date`
+   * lisait une heure SANS decalage dans le fuseau du NAVIGATEUR, a quelques heures de celle de
+   * l'application (audit du 2026-09-27, A-4) ; une ecriture non ISO est illisible (`NaN`).
+   */
+  private dateEnMillisecondes;
+  protected readonly estValide: import("@angular/core").Signal<boolean>;
+  protected readonly iso: import("@angular/core").Signal<string | null>;
+  protected readonly depasseLeSeuil: import("@angular/core").Signal<boolean>;
+  protected readonly texte: import("@angular/core").Signal<string>;
+  /** L'absolu visible (`avecAbsolu`), sauf quand le texte est deja une date absolue. */
+  protected readonly absoluVisible: import("@angular/core").Signal<string | null>;
+  /** Lu a la place du relatif quand l'absolu n'est pas a l'ecran : il ne bouge pas. */
+  protected readonly texteAccessible: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRelativeTime, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRelativeTime, "st-relative-time", never, {
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "rafraichir": {
+      "alias": "rafraichir";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "avecAbsolu": {
+      "alias": "avecAbsolu";
+      "required": false;
+      "isSignal": true;
+    };
+    "seuilAbsoluEnJours": {
+      "alias": "seuilAbsoluEnJours";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** `primaire` : la valeur appuyee d'un indicateur (« 142 » operations en cours, planche 2). */
+export type TonDeCompte = Extract<Ton, 'neutre' | 'discret' | 'primaire'>;
+/** Unites simples d'Intl (`style: 'unit'`) : « 12 Mo », « 3 jours ». */
+export type UniteDeCompte = 'byte' | 'kilobyte' | 'megabyte' | 'gigabyte' | 'terabyte' | 'percent' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+/**
+ * Nombre dans le flux du texte.
+ *
+ * Distinct de `st-badge`, qui est une pastille superposee a un autre element.
+ *
+ * ⚠️ Ce qui se lit est ce qui se voit : le nombre n'est masque aux technologies
+ * d'assistance que quand il est ABREGE (« 1,2 k »), et le nom accessible porte
+ * alors le nombre COMPLET — l'abreviation est une commodite visuelle, pas une perte
+ * d'information pour qui ecoute la page. Un nombre entier se lit tel qu'affiche (la
+ * 0.8 le masquait sans rien lire a sa place).
+ *
+ * Le corps et la graisse sont ceux du texte qui l'entoure : dans une phrase, dans la
+ * valeur d'un `st-stat` (32/40 600, planche 2), dans une cellule. `bigint` accepte : un
+ * compteur de base ne tient pas toujours dans un nombre a virgule flottante.
+ */
+export declare class StCount {
+  private readonly locale;
+  readonly valeur: import("@angular/core").InputSignal<number | bigint>;
+  readonly ton: import("@angular/core").InputSignal<TonDeCompte>;
+  /** Unite formatee par Intl (« 12 Mo ») ; une phrase (« 3 fichiers ») reste a l'appelant. */
+  readonly unite: import("@angular/core").InputSignal<UniteDeCompte | null>;
+  /** `null` : jamais d'abreviation (contexte comptable). */
+  readonly abregerAuDela: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+  private readonly absolu;
+  protected readonly estAbrege: import("@angular/core").Signal<boolean>;
+  private readonly optionsDUnite;
+  protected readonly texteComplet: import("@angular/core").Signal<string>;
+  protected readonly texte: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCount, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StCount, "st-count", never, {
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "unite": {
+      "alias": "unite";
+      "required": false;
+      "isSignal": true;
+    };
+    "abregerAuDela": {
+      "alias": "abregerAuDela";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * `pourcentage` : la valeur EN POUR CENT, telle que l'API la donne (3.25 s'ecrit « 3,25 % » en
+ * francais, « 3.25% » en anglais) ; `unite` : avec son unite (« 12 mois », « 250 ko »).
+ */
+export type FormatDeNombre = 'decimal' | 'pourcentage' | 'unite';
+/** Les unites d'Intl, sans `percent` : un pourcentage se dit par `format="pourcentage"`. */
+export type UniteDeNombre = Exclude<UniteDeCompte, 'percent'>;
+/** Decimales fixes (`2` : « 3,20 ») ou bornees (`{ min: 0, max: 2 }` : « 3 », « 3,2 », « 3,25 »). */
+export type DecimalesDeNombre = number | {
+  readonly min: number;
+  readonly max: number;
+};
+/** Les tons de `st-money` : un statut choisi par l'appelant, jamais deduit du signe. */
+export type TonDeNombre = Extract<Ton, 'neutre' | 'discret' | 'primaire' | 'succes' | 'danger'>;
+/**
+ * Un nombre qui n'est ni un montant (`st-money`) ni un compte (`st-count`) : un taux, un TAEG, une
+ * quantite decimale, une grandeur avec son unite (lot 256).
+ *
+ * ```html
+ * <st-number [valeur]="3.25" format="pourcentage" />
+ * <st-number [valeur]="250" format="unite" unite="kilobyte" [decimales]="0" />
+ * ```
+ *
+ * Formate par Intl dans la locale COURANTE (`ST_LOCALE`) : il suit une bascule de langue sans
+ * rechargement ; jamais les tuyaux `number` et `percent` d'Angular, figes sur `LOCALE_ID`.
+ *
+ * ⚠️ **Ce qui se lit est ce qui se voit**, sauf une unite abregee et un signe moins : « 250 ko »
+ * s'affiche et « 250 kilooctets » se lit a sa place ; « −0,12 % », en vrai signe moins (U+2212,
+ * D30), se lit « moins 0,12 % », comme un montant. La valeur machine va dans `<data value>`.
+ * Jamais dans une region vivante.
+ *
+ * `variation` : le signe se RENFORCE par la couleur (`--st-couleur-positif`, `--st-couleur-negatif`),
+ * comme `st-money` ; `ton` prime, choisi par l'appelant (une baisse de marche en `danger`).
+ */
+export declare class StNumber {
+  private readonly locale;
+  private readonly libelles;
+  readonly valeur: import("@angular/core").InputSignal<number | bigint>;
+  readonly format: import("@angular/core").InputSignal<FormatDeNombre>;
+  readonly decimales: import("@angular/core").InputSignal<DecimalesDeNombre>;
+  /** L'unite de `format="unite"` ; sans elle, un nombre decimal. */
+  readonly unite: import("@angular/core").InputSignal<UniteDeNombre | null>;
+  /** « +0,25 % » : le signe d'une variation positive ; zero n'en porte pas. */
+  readonly signeExplicite: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Une hausse ou une baisse : la couleur renforce le signe, deja ecrit. */
+  readonly variation: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `null` : l'encre du texte, ou celle de la variation. */
+  readonly ton: import("@angular/core").InputSignal<TonDeNombre | null>;
+  /** Zero n'a pas de signe, pas meme « -0 ». */
+  private readonly lue;
+  protected readonly signe: import("@angular/core").Signal<"negatif" | "positif" | "nul">;
+  private readonly options;
+  protected readonly texte: import("@angular/core").Signal<string>;
+  /**
+   * Ce qui se lit a la place du texte : l'unite en toutes lettres, « moins » devant un nombre
+   * negatif ; `null` : le texte se lit tel qu'il se voit.
+   */
+  protected readonly texteLu: import("@angular/core").Signal<string | null>;
+  /** La valeur telle que recue, pour `<data value>`. */
+  protected readonly valeurMachine: import("@angular/core").Signal<string>;
+  private formater;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StNumber, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StNumber, "st-number", never, {
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+    "decimales": {
+      "alias": "decimales";
+      "required": false;
+      "isSignal": true;
+    };
+    "unite": {
+      "alias": "unite";
+      "required": false;
+      "isSignal": true;
+    };
+    "signeExplicite": {
+      "alias": "signeExplicite";
+      "required": false;
+      "isSignal": true;
+    };
+    "variation": {
+      "alias": "variation";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Une duree en parties : « 25 ans », « 3 jours », « 1 heure et 30 minutes ». */
+export interface PartiesDeDuree {
+  readonly annees?: number;
+  readonly mois?: number;
+  readonly semaines?: number;
+  readonly jours?: number;
+  readonly heures?: number;
+  readonly minutes?: number;
+  readonly secondes?: number;
+}
+/** `court` : « 1 h et 30 min », lu en toutes lettres ; `long` : « 1 heure et 30 minutes ». */
+export type FormatDeDuree = 'court' | 'long';
+/**
+ * Une duree affichee (lot 256) : le delai d'un traitement, la duree d'un pret, un temps passe.
+ *
+ * ```html
+ * <st-duration [secondes]="5400" />                     <!-- « 1 h et 30 min » -->
+ * <st-duration [parties]="{ annees: 25 }" format="long" /> <!-- « 25 ans » -->
+ * ```
+ *
+ * `Intl.DurationFormat` dans la locale COURANTE (`ST_LOCALE`), et, sans lui, chaque unite par
+ * `Intl.NumberFormat` jointe par `Intl.ListFormat` : l'ordre, les abreviations et la conjonction
+ * suivent la langue, sans table maison.
+ *
+ * ⚠️ Le format court se LIT en toutes lettres : « 1 h 30 » est ambigu a l'oral. Une duree
+ * connue a la seconde porte sa valeur machine (`<time datetime="PT5400S">`).
+ *
+ * ⚠️ Jamais dans une region vivante : ce n'est pas un compte a rebours (`st-timer` en est un).
+ */
+export declare class StDuration {
+  private readonly locale;
+  /** Une duree en secondes, decomposee en jours, heures, minutes et secondes. */
+  readonly secondes: import("@angular/core").InputSignal<number | null>;
+  /** Une duree en parties (annees, mois...) ; ignoree quand `secondes` est donnee. */
+  readonly parties: import("@angular/core").InputSignal<PartiesDeDuree | null>;
+  readonly format: import("@angular/core").InputSignal<FormatDeDuree>;
+  /** Les secondes, entieres et positives ; `null` sans duree en secondes. */
+  private readonly totalEnSecondes;
+  private readonly partiesLues;
+  protected readonly texte: import("@angular/core").Signal<string>;
+  /** Le format court en toutes lettres, lu a sa place ; `null` en format long. */
+  protected readonly texteLu: import("@angular/core").Signal<string | null>;
+  /** `PT5400S` : la duree a la seconde, pour `<time datetime>` ; `null` quand elle est en parties. */
+  protected readonly valeurMachine: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDuration, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDuration, "st-duration", never, {
+    "secondes": {
+      "alias": "secondes";
+      "required": false;
+      "isSignal": true;
+    };
+    "parties": {
+      "alias": "parties";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export type SensDeTendance = 'hausse' | 'baisse' | 'stable';
+/** La tendance d'un indicateur, decrite par l'appelant. Les textes sont deja traduits. */
+export interface TendanceDeStat {
+  /** Le sens de la variation. Absent : un constat sans direction (« 14 prioritaires »). */
+  readonly sens?: SensDeTendance;
+  /** Ce qui s'affiche DANS la pastille : « +2,4 % ». Absent quand `montant` le dit. */
+  readonly texte?: string;
+  /**
+   * Une variation en argent (« +1 250,00 € ») : rendue par `st-money`, signe explicite, et
+   * masquee avec les montants de l'ecran (`ST_MONTANTS_MASQUES`, lot 256), ce qu'un texte ne
+   * serait pas.
+   */
+  readonly montant?: Montant;
+  /** Ce qui la suit, hors pastille : « sur un mois glissant » (planche 2). */
+  readonly contexte?: string;
+  /**
+   * ⚠️ Choisi par l'appelant, et non deduit du sens : une hausse des frais est
+   * un `danger`, une hausse de l'epargne un `succes`. Le socle ne sait pas
+   * lequel des deux il affiche.
+   */
+  readonly ton?: TonSemantique;
+  /** La forme, quand le sens ne la donne pas (`priorite-haute` d'un constat d'alerte). */
+  readonly icone?: Icone;
+}
+/**
+ * Indicateur chiffre : un libelle, une valeur, sa tendance et sa precision.
+ *
+ * ```html
+ * <st-stat libelle="Solde disponible" icone="banque" precision="Au 20 septembre 2026, 09:30"
+ *   [tendance]="{ sens: 'hausse', texte: '+2,4 %', contexte: 'sur un mois', ton: 'succes' }">
+ *   <st-money [valeur]="solde" />
+ * </st-stat>
+ * ```
+ *
+ * La valeur est PROJETEE : c'est `st-money`, `st-count` ou `st-date` qui la
+ * formate dans la langue courante, dans la composition du chiffre cle que la
+ * valeur lui transmet (32/40 600, planche 2).
+ *
+ * ⚠️ **La tendance se lit par un texte ET une forme, jamais par la couleur
+ * seule.** Le texte de l'appelant porte deja le signe ; l'icone porte le sens ;
+ * et un mot lisible par lecteur seulement (« en hausse », « en baisse »,
+ * « stable ») precede le texte, parce qu'un lecteur d'ecran ne lit pas un
+ * triangle.
+ *
+ * Le libelle vient AVANT la valeur dans le document, comme dans une phrase, et
+ * nomme le groupe (`role="group"`) : « Solde disponible, groupe ». A l'ecran, il
+ * se pose au-dessus, en micro-capitales. Un bouton d'aide se projette a cote de
+ * lui (`[aide]`), nomme « A propos de {libelle} » par le dictionnaire (`aProposDe`).
+ */
+export declare class StStat {
+  private readonly libelles;
+  private readonly element;
+  /** Texte visible, deja traduit. */
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  /** Icone decorative a droite du libelle (planche 2). Sans effet a cote d'une aide projetee. */
+  readonly icone: import("@angular/core").InputSignal<Icone | null>;
+  readonly tendance: import("@angular/core").InputSignal<TendanceDeStat | null>;
+  /** Precision sous la valeur : la periode, la source. Jamais une information critique. */
+  readonly precision: import("@angular/core").InputSignal<string | null>;
+  protected readonly identifiantDuLibelle: string;
+  /** Le libelle et la valeur vont ensemble : un groupe, nomme par le libelle. */
+  private readonly role;
+  private readonly nommePar;
+  constructor();
+  protected readonly iconeDeTendance: import("@angular/core").Signal<Icone | null>;
+  /**
+   * Les triangles d'une variation ont de l'air dans leur boite : 16 px pour eux, a 2 px du
+   * texte, 14 px pour les formes pleines, a 4 px (planche 2).
+   */
+  protected readonly tailleDeLIcone: import("@angular/core").Signal<TailleDIconeFixe>;
+  protected readonly tonDeTendance: import("@angular/core").Signal<TonSemantique>;
+  protected readonly sensLu: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StStat, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StStat, "st-stat", never, {
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "tendance": {
+      "alias": "tendance";
+      "required": false;
+      "isSignal": true;
+    };
+    "precision": {
+      "alias": "precision";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[aide]", "*"], true, never>;
+}
+/**
+ * `ligne` : un montant qui compte (« Montant du virement ») ; `deduction` : retranche, toujours
+ * signe (« Remise −5,00 € ») ; `taux` : un texte (« 1 EUR = 1,08 USD, taux garanti 10 min ») ;
+ * `total` et `solde` : au pied du tableau, le total appuye, le solde apres operation discret.
+ */
+export type TypeDeLigneDeMontant = 'ligne' | 'deduction' | 'taux' | 'total' | 'solde';
+/** Une ligne du recapitulatif. Les textes sont deja traduits. */
+export interface LigneDeMontant {
+  readonly cle: string;
+  readonly libelle: string;
+  /** Le montant ; celui d'une `deduction` s'affiche retranche, quel que soit son signe. */
+  readonly montant?: Montant;
+  /** Le texte d'une ligne sans montant (`taux`). */
+  readonly texte?: string;
+  /** `ligne` par defaut. */
+  readonly type?: TypeDeLigneDeMontant;
+  /** Sous le libelle, en discret : une periode, une condition. */
+  readonly precision?: string;
+}
+interface LigneLue$1 extends LigneDeMontant {
+  readonly type: TypeDeLigneDeMontant;
+  readonly montantLu: Montant | null;
+  /** Le total a l'encre primaire, le solde en discret (planche 11). */
+  readonly ton: TonDeMontant | null;
+}
+/**
+ * Le recapitulatif chiffre d'une operation avant qu'on la confirme (lot 256) : montant, frais,
+ * taux, total debite, solde apres operation. La DSP2 exige les frais et le taux AVANT la
+ * confirmation ; des montants alignes dans des `div` ne disent pas la relation entre les lignes.
+ *
+ * ```html
+ * <st-amount-summary legende="Recapitulatif du virement" [lignes]="lignes" />
+ * ```
+ *
+ * ```ts
+ * const total = sommerMontants(montant, frais); // jamais en virgule flottante
+ * lignes = [
+ *   { cle: 'montant', libelle: 'Montant', montant },
+ *   { cle: 'frais', libelle: 'Frais', montant: frais },
+ *   { cle: 'total', libelle: 'Total debite', montant: total, type: 'total' },
+ * ];
+ * ```
+ *
+ * ⚠️ **Un tableau natif**, legende en `caption` (masquable), libelles en en-tetes de ligne : la
+ * ligne se lit « Frais, 0,80 € ». Le total et le solde vont au pied (`tfoot`). Le composant ne
+ * calcule rien : l'appelant somme par `sommerMontants`, qui refuse les devises melees.
+ *
+ * Planche 11 : libelles discrets, montants en chasse fixe (leurs virgules s'alignent), total a
+ * l'encre primaire. Une deduction reste a l'encre du texte, signee : un debit n'est pas une erreur
+ * (D30).
+ *
+ * Les montants suivent `ST_MONTANTS_MASQUES` (`st-money`).
+ */
+export declare class StAmountSummary {
+  /** Le nom du tableau, en `caption`. */
+  readonly legende: import("@angular/core").InputSignal<string>;
+  /** La legende est lue sans etre vue : un titre de section la dit deja. */
+  readonly legendeMasquee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly lignes: import("@angular/core").InputSignal<readonly LigneDeMontant[]>;
+  /** La colonne est deja titree par sa devise. */
+  readonly sansDevise: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly lignesLues;
+  protected readonly corps: import("@angular/core").Signal<LigneLue$1[]>;
+  protected readonly pied: import("@angular/core").Signal<LigneLue$1[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StAmountSummary, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StAmountSummary, "st-amount-summary", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "legendeMasquee": {
+      "alias": "legendeMasquee";
+      "required": false;
+      "isSignal": true;
+    };
+    "lignes": {
+      "alias": "lignes";
+      "required": true;
+      "isSignal": true;
+    };
+    "sansDevise": {
+      "alias": "sansDevise";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * `barre` (planches 13-2 et 14) : libelle, valeur sur total, piste de 8 px ; `puce` (planche 16) :
+ * piste de 24 px a trois regions, marqueur de la valeur et trait du seuil ; `cellule` (planche 14) :
+ * la valeur sur son total et une piste de 6 px, a la taille d'une cellule, le libelle lu seulement.
+ */
+export type VarianteDeJauge = 'barre' | 'puce' | 'cellule';
+/** Ce que dit le texte : ce qui est consomme, ce qui reste, ou la part. */
+export type AffichageDeJauge = 'consomme' | 'reste' | 'pourcentage';
+export type TonDeJauge = Extract<TonSemantique, 'primaire' | 'succes' | 'avertissement' | 'danger'>;
+/** Les trois qualites d'une region de `<meter>` (HTML) : optimale, sous-optimale, pire. */
+export type QualiteDeZone = 'optimale' | 'sous-optimale' | 'pire';
+/** Une region de la piste, en part de la plage (0 a 1), et sa qualite. */
+export interface ZoneDeJauge {
+  readonly debut: number;
+  readonly fin: number;
+  readonly qualite: QualiteDeZone;
+}
+/** Un morceau d'une phrase de valeur : du texte, la valeur, ou le total. */
+interface MorceauDeValeur {
+  readonly nature: 'texte' | 'valeur' | 'total';
+  readonly texte: string;
+}
+/**
+ * Les regions de `<meter>` et leur qualite, selon la regle de HTML : l'optimum dans la region
+ * basse la rend optimale (la haute est la pire), dans la haute l'inverse, au milieu les deux bouts
+ * sont sous-optimaux. Sans `bas` ni `haut`, AUCUNE region : la jauge ne juge pas.
+ */
+export declare function zonesDeJauge(min: number, max: number, bas: number | null, haut: number | null, optimum: number | null): readonly ZoneDeJauge[];
+/**
+ * Une jauge de NIVEAU (lot 257) : un plafond de carte consomme, un quota, un ratio sous son seuil.
+ * Pas une progression d'activite (`st-progress`, `progressbar`) : un `<meter>` natif, nomme par son
+ * libelle, et une valeur TOUJOURS dite en texte.
+ *
+ * ```html
+ * <!-- consomme, plafond, alerte : des unites mineures (bigint) venues de l'API -->
+ * <st-meter libelle="Plafond de paiement mensuel" [valeur]="consomme" [max]="plafond"
+ *   devise="CHF" [haut]="alerte" [optimum]="0" precision="Reinitialise le 1er octobre" />
+ * ```
+ *
+ * - `devise` : les valeurs sont des UNITES MINEURES de cette devise (comme `Montant`), dites par
+ *   `st-money` et masquees avec les montants de l'ecran (`ST_MONTANTS_MASQUES`) ; la piste reste,
+ *   elle ne dit qu'une part.
+ * - Le ton suit les regions de `<meter>` (`bas`, `haut`, `optimum`) : optimale en primaire,
+ *   sous-optimale en avertissement, pire en danger. Sans region, aucun ton deduit ; `ton` l'impose.
+ * - `[texte]` projete remplace la phrase du dictionnaire : une puce dit souvent sa valeur ET son
+ *   seuil, dans les mots du metier (« Ratio post-choc : 128,4 % / minimum legal : 100 % »).
+ * - Le `<meter>` natif porte la semantique (nom, valeur, plage) ; le dessin est muet. Sous
+ *   contraste force, la piste garde un filet et le niveau la couleur de selection du systeme.
+ */
+export declare class StMeter {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  private readonly masques;
+  private readonly identifiants;
+  protected readonly idDuLibelle: string;
+  protected readonly idDeLaValeur: string;
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  readonly valeur: import("@angular/core").InputSignal<number | bigint>;
+  readonly max: import("@angular/core").InputSignal<number | bigint>;
+  readonly min: import("@angular/core").InputSignal<number | bigint>;
+  /** Borne haute de la region basse de `<meter>` (`low`). */
+  readonly bas: import("@angular/core").InputSignal<number | bigint | null>;
+  /** Borne basse de la region haute (`high`). */
+  readonly haut: import("@angular/core").InputSignal<number | bigint | null>;
+  /** La valeur ideale (`optimum`) : elle dit laquelle des regions est la bonne. */
+  readonly optimum: import("@angular/core").InputSignal<number | bigint | null>;
+  /** Le trait d'un seuil a ne pas franchir (variante `puce`) : un minimum legal, un plafond. */
+  readonly seuil: import("@angular/core").InputSignal<number | bigint | null>;
+  /** Code ISO 4217 : les valeurs sont des unites mineures de cette devise. */
+  readonly devise: import("@angular/core").InputSignal<string | null>;
+  readonly affichage: import("@angular/core").InputSignal<AffichageDeJauge>;
+  /** Ce qui suit la jauge (« Reinitialise le 1er octobre »), deja traduit. */
+  readonly precision: import("@angular/core").InputSignal<string | null>;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeJauge>;
+  /** Impose un ton ; `null` : celui des regions, s'il y en a. */
+  readonly ton: import("@angular/core").InputSignal<TonDeJauge | null>;
+  /** La part en pastille, a droite du libelle (planche 14). */
+  readonly partVisible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly nombres: import("@angular/core").Signal<{
+    min: number;
+    max: number;
+    valeur: number;
+  }>;
+  /** La part de la plage, de 0 a 1. */
+  protected readonly part: import("@angular/core").Signal<number>;
+  protected readonly zones: import("@angular/core").Signal<readonly ZoneDeJauge[]>;
+  protected readonly tonLu: import("@angular/core").Signal<TonDeJauge>;
+  protected readonly partDuSeuil: import("@angular/core").Signal<number | null>;
+  protected readonly pourcentage: import("@angular/core").Signal<string>;
+  protected readonly montant: import("@angular/core").Signal<Montant | null>;
+  protected readonly total: import("@angular/core").Signal<Montant | null>;
+  protected readonly reste: import("@angular/core").Signal<Montant | null>;
+  protected readonly nombreDuReste: import("@angular/core").Signal<number>;
+  /** Ce que dit le compteur quand les montants sont masques : ni le montant, ni son total. */
+  protected readonly texteMasque: import("@angular/core").Signal<string | null>;
+  protected readonly morceauxDuConsomme: import("@angular/core").Signal<readonly MorceauDeValeur[]>;
+  protected readonly morceauxDuReste: import("@angular/core").Signal<readonly MorceauDeValeur[]>;
+  private enMontant;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMeter, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMeter, "st-meter", never, {
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": true;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "bas": {
+      "alias": "bas";
+      "required": false;
+      "isSignal": true;
+    };
+    "haut": {
+      "alias": "haut";
+      "required": false;
+      "isSignal": true;
+    };
+    "optimum": {
+      "alias": "optimum";
+      "required": false;
+      "isSignal": true;
+    };
+    "seuil": {
+      "alias": "seuil";
+      "required": false;
+      "isSignal": true;
+    };
+    "devise": {
+      "alias": "devise";
+      "required": false;
+      "isSignal": true;
+    };
+    "affichage": {
+      "alias": "affichage";
+      "required": false;
+      "isSignal": true;
+    };
+    "precision": {
+      "alias": "precision";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "partVisible": {
+      "alias": "partVisible";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[texte]"], true, never>;
+}
+/** Ou en est une echeance : a temps, urgente (sous le seuil declare), depassee. */
+export type EtatDEcheance = 'a-temps' | 'urgente' | 'depassee';
+/**
+ * Une echeance (lot 257) : un SLA de back-office, une reponse due, un justificatif qui expire, un
+ * taux garanti. Le delai (« dans 2 h »), la date absolue, et l'etat en MOT et en forme.
+ *
+ * ```html
+ * <st-deadline libelle="Reponse due" echeance="2026-10-15T17:00:00+02:00"
+ *   [seuilUrgentEnMinutes]="120" (depassee)="signaler()" />
+ * ```
+ *
+ * - Urgente seulement sous un seuil DECLARE (`seuilUrgentEnMinutes`) : sans seuil, a temps ou
+ *   depassee, jamais une urgence deduite.
+ * - Jamais dans une region vivante : un tableau de cinquante echeances n'annonce rien ; le
+ *   passage a « depassee » n'est pas annonce, l'application decide (`(depassee)`, emise une fois).
+ * - L'etat se relit chaque minute, jamais quand l'onglet est masque (Page Visibility).
+ */
+export declare class StDeadline {
+  private readonly document;
+  private readonly fuseau;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  /** L'instant ISO de l'echeance (avec son decalage), ou une `Date`. */
+  readonly echeance: import("@angular/core").InputSignal<string | Date>;
+  /** Ce qui echoit (« Reponse due »), deja traduit ; `null` : l'etat et le delai seuls. */
+  readonly libelle: import("@angular/core").InputSignal<string | null>;
+  /** Sous ce nombre de minutes restantes, l'echeance est urgente ; `null` : jamais. */
+  readonly seuilUrgentEnMinutes: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+  /** La date absolue a l'ecran ; sinon, elle se lit seulement (nom de `st-relative-time`). */
+  readonly absoluVisible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** L'echeance vient de passer : emise une fois, a la bascule, jamais au chargement deja passe. */
+  readonly depassee: import("@angular/core").OutputEmitterRef<void>;
+  private readonly maintenant;
+  /**
+   * L'instant de l'echeance, lu par `lireInstant` dans le fuseau de l'application : `Date.parse`
+   * lisait une heure sans decalage dans celui du NAVIGATEUR, et une echeance depassee pouvait se
+   * dire « a temps » (audit du 2026-09-27, A-4).
+   */
+  protected readonly instant: import("@angular/core").Signal<number>;
+  /** Le delai relatif recoit l'instant DEJA lu : les deux ne peuvent pas diverger. */
+  protected readonly dateDeLEcheance: import("@angular/core").Signal<Date>;
+  protected readonly etat: import("@angular/core").Signal<EtatDEcheance>;
+  protected readonly icone: import("@angular/core").Signal<Icone>;
+  protected readonly mot: import("@angular/core").Signal<string>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDeadline, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDeadline, "st-deadline", never, {
+    "echeance": {
+      "alias": "echeance";
+      "required": true;
+      "isSignal": true;
+    };
+    "libelle": {
+      "alias": "libelle";
+      "required": false;
+      "isSignal": true;
+    };
+    "seuilUrgentEnMinutes": {
+      "alias": "seuilUrgentEnMinutes";
+      "required": false;
+      "isSignal": true;
+    };
+    "absoluVisible": {
+      "alias": "absoluVisible";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "depassee": "depassee";
+  }, never, never, true, never>;
+}
+/** `sm` : un avatar de 24 px dans une ligne dense ; `md` (defaut) : 32 px (planche 14). */
+export type TailleDePersonne = 'sm' | 'md';
+/** `ligne` : l'avatar a gauche du nom ; `colonne` : au-dessus, pour une carte. */
+export type DispositionDePersonne = 'ligne' | 'colonne';
+/**
+ * Une personne (lot 257) : l'agent assigne a un dossier, l'auteur d'une action d'audit, le
+ * signataire d'un virement a plusieurs mains, un conseiller.
+ *
+ * ```html
+ * <st-person nom="Adrian von Burg" precision="Direction generale • MAT-0081" [lien]="['/agents', 81]" />
+ * ```
+ *
+ * - Le NOM est du texte ; l'avatar est decoratif (`nomAdjacent`), aucune couleur derivee du nom.
+ * - Le lien, s'il existe, porte le nom seul : ni l'avatar ni la precision ne sont cliquables.
+ * - `soi` : « (vous) » apres le nom, pour la personne connectee.
+ */
+export declare class StPerson {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  readonly nom: import("@angular/core").InputSignal<string>;
+  /** Le role, le service, le matricule : deja traduits. */
+  readonly precision: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Nom et precision sont des donnees (l'auteur d'un message, un titulaire) : sans commande de
+   * direction, et isoles (`dir="auto"`) dans la ligne (audit du 2026-09-27, A-2).
+   */
+  protected readonly nomAffiche: import("@angular/core").Signal<string>;
+  protected readonly precisionAffichee: import("@angular/core").Signal<string | null>;
+  readonly sourceImage: import("@angular/core").InputSignal<string | null>;
+  /** La route de la fiche : le nom devient un lien, lui seul. */
+  readonly lien: import("@angular/core").InputSignal<string | readonly unknown[] | null>;
+  readonly taille: import("@angular/core").InputSignal<TailleDePersonne>;
+  readonly disposition: import("@angular/core").InputSignal<DispositionDePersonne>;
+  readonly ton: import("@angular/core").InputSignal<TonDAvatar>;
+  readonly soi: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly tailleDeLAvatar: import("@angular/core").Signal<"sm" | "xs">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPerson, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StPerson, "st-person", never, {
+    "nom": {
+      "alias": "nom";
+      "required": true;
+      "isSignal": true;
+    };
+    "precision": {
+      "alias": "precision";
+      "required": false;
+      "isSignal": true;
+    };
+    "sourceImage": {
+      "alias": "sourceImage";
+      "required": false;
+      "isSignal": true;
+    };
+    "lien": {
+      "alias": "lien";
+      "required": false;
+      "isSignal": true;
+    };
+    "taille": {
+      "alias": "taille";
+      "required": false;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+    "soi": {
+      "alias": "soi";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Une personne de la pile : son nom (lu), sa photo s'il y en a une. */
+export interface PersonneDeGroupe {
+  readonly nom: string;
+  readonly sourceImage?: string | null;
+}
+/**
+ * Une pile d'avatars (lot 257) : les conseillers d'un dossier, les valideurs d'une operation.
+ *
+ * ```html
+ * <st-avatar-group etiquette="Valideurs" [personnes]="valideurs" [max]="4" (reste)="ouvrirLaListe()" />
+ * ```
+ *
+ * - Une liste NOMMEE ; chaque avatar dit son nom (il n'est pas a cote : `nomAdjacent` faux).
+ * - Au-dela de `max`, les `max - 1` premiers, puis « +3 » : un BOUTON nomme « 3 autres
+ *   personnes », qui emet `reste` ; la liste complete (un `st-popover`) appartient a l'appelant.
+ * - Aucune couleur derivee du nom (garantie de `st-avatar`).
+ *
+ * Dans `ui/donnees` et non au tronc : la coquille ne peint qu'un avatar (D142).
+ */
+export declare class StAvatarGroup {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  readonly personnes: import("@angular/core").InputSignal<readonly PersonneDeGroupe[]>;
+  /** Le nom de la liste (« Valideurs du virement »), deja traduit. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly taille: import("@angular/core").InputSignal<TailleDAvatar>;
+  /** « +3 » : la personne veut la liste complete. */
+  readonly reste: import("@angular/core").OutputEmitterRef<void>;
+  /** Les personnes montrees : toutes, ou `max - 1` et le bouton du reste. */
+  protected readonly montrees: import("@angular/core").Signal<readonly PersonneDeGroupe[]>;
+  protected readonly surplus: import("@angular/core").Signal<number>;
+  /**
+   * « +3 » dans la locale du socle, signe compris (`signDisplay`) : ecrit a la main, le nombre
+   * restait en chiffres latins a cote d'une interface qui ne les emploie pas (audit UI du
+   * 2026-09-27, D-27).
+   */
+  protected readonly surplusAffiche: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StAvatarGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StAvatarGroup, "st-avatar-group", never, {
+    "personnes": {
+      "alias": "personnes";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "taille": {
+      "alias": "taille";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "reste": "reste";
+  }, never, never, true, never>;
+}
+/** `auto` : autant de colonnes de 14 rem que la largeur en tient ; sinon, le nombre vise. */
+export type ColonnesDIndicateurs = 'auto' | 2 | 3 | 4 | 6;
+/**
+ * Un groupe d'indicateurs (lot 257) : les trois a six `st-stat` d'un tableau de bord, lus comme
+ * une liste NOMMEE (« Indicateurs du jour, 4 elements »), chacun groupe nomme par son libelle.
+ *
+ * ```html
+ * <st-stat-group etiquette="Indicateurs du jour" [colonnes]="4">
+ *   <li><st-stat libelle="Solde disponible">…</st-stat></li>
+ *   <li><st-stat libelle="Ordres en attente">…</st-stat></li>
+ * </st-stat-group>
+ * ```
+ *
+ * La grille suit la largeur de SON conteneur (requete de conteneur), pas celle de la fenetre :
+ * une colonne a 320 px, deux des `sm`, le nombre vise des `lg` (six : deux, trois, puis six).
+ * Les elements de liste sont ecrits par l'appelant : une projection ne sait pas envelopper.
+ */
+export declare class StStatGroup {
+  /** Le nom de la liste, deja traduit. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  readonly colonnes: import("@angular/core").InputSignal<ColonnesDIndicateurs>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StStatGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StStatGroup, "st-stat-group", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "colonnes": {
+      "alias": "colonnes";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Une ligne : sa cle, son libelle deja traduit, sa valeur (unites mineures avec `devise`). */
+export interface LigneDeBarres {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly valeur: number | bigint;
+}
+/** Ce que disent les colonnes de chiffres : la valeur, la part du total, ou les deux. */
+export type AffichageDeBarres = 'valeur' | 'part' | 'les-deux';
+/** Une ligne prete a rendre : sa valeur, sa part du total, sa longueur de barre. */
+interface LigneLue {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly nombre: number;
+  readonly montant: Montant | null;
+  readonly part: string;
+  readonly longueur: number;
+}
+/**
+ * Une comparaison de categories (lot 257) : depenses du mois par categorie, volume par file, part
+ * de chaque classe d'actifs. Un TABLEAU natif, lisible sans ses barres : libelle en en-tete de
+ * ligne, valeur et part en cellules ; la barre, muette, est proportionnelle a la plus grande.
+ *
+ * ```html
+ * <st-bar-list legende="Depenses de septembre" devise="EUR" [lignes]="depenses" [limite]="5" />
+ * ```
+ *
+ * - `limite` : les N plus grandes, puis « Autres » qui regroupe le reste.
+ * - Une seule encre (primaire) : aucune legende de couleur a apprendre. Aucune animation.
+ * - Tout graphique a axe reste hors du socle : ce composant n'en trace pas.
+ */
+export declare class StBarList {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  readonly lignes: import("@angular/core").InputSignal<readonly LigneDeBarres[]>;
+  /** La legende du tableau, deja traduite. */
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly legendeMasquee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Code ISO 4217 : les valeurs sont des unites mineures de cette devise. */
+  readonly devise: import("@angular/core").InputSignal<string | null>;
+  readonly affichage: import("@angular/core").InputSignal<AffichageDeBarres>;
+  /** Les N plus grandes lignes, puis « Autres » ; `null` : toutes, dans l'ordre donne. */
+  readonly limite: import("@angular/core").InputSignal<number | null>;
+  protected readonly lues: import("@angular/core").Signal<readonly LigneLue[]>;
+  protected readonly avecValeur: import("@angular/core").Signal<boolean>;
+  protected readonly avecPart: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StBarList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StBarList, "st-bar-list", never, {
+    "lignes": {
+      "alias": "lignes";
+      "required": true;
+      "isSignal": true;
+    };
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "legendeMasquee": {
+      "alias": "legendeMasquee";
+      "required": false;
+      "isSignal": true;
+    };
+    "devise": {
+      "alias": "devise";
+      "required": false;
+      "isSignal": true;
+    };
+    "affichage": {
+      "alias": "affichage";
+      "required": false;
+      "isSignal": true;
+    };
+    "limite": {
+      "alias": "limite";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Une part : sa cle, son libelle deja traduit, sa valeur (unites mineures avec `devise`). */
+export interface PartDeRepartition {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly valeur: number | bigint;
+}
+/** `sous` : la legende sous la barre ; `masquee` : lue seulement (la barre reste muette). */
+export type LegendeDeRepartition = 'sous' | 'masquee';
+/** `fine` : 6 px (planche 14) ; `epaisse` : 16 px, ou les motifs se voient. */
+export type EpaisseurDeRepartition = 'fine' | 'epaisse';
+/** Une part prete a rendre : sa place dans la barre, sa serie (teinte et motif), sa part. */
+interface PartLue {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly nombre: number;
+  readonly montant: Montant | null;
+  readonly proportion: number;
+  readonly part: string;
+  readonly serie: number;
+}
+/**
+ * Une repartition (lot 257) : la structure d'un portefeuille, les depenses par poste, la part de
+ * chaque canal. Une barre segmentee et sa LEGENDE, qui est la donnee : une liste ordonnee, chaque
+ * part avec sa valeur et son pourcentage ; la barre est muette.
+ *
+ * ```html
+ * <st-repartition etiquette="Structure du portefeuille" devise="CHF" [parts]="classes" />
+ * ```
+ *
+ * - Une serie par teinte du primaire et, des la seconde, par motif (hachures, points, croisillons)
+ *   et un filet de separation : la couleur n'est jamais seule, ni sous contraste force.
+ * - Aucune animation, une seule serie par segment ; tout graphique a axe reste hors du socle.
+ * - Une alternative tabulaire, quand il faut trier ou comparer : `st-data-table`.
+ */
+export declare class StRepartition {
+  private readonly locale;
+  readonly parts: import("@angular/core").InputSignal<readonly PartDeRepartition[]>;
+  /** Le nom de la repartition (« Structure du portefeuille »), deja traduit. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  /** Code ISO 4217 : les valeurs sont des unites mineures de cette devise. */
+  readonly devise: import("@angular/core").InputSignal<string | null>;
+  readonly legende: import("@angular/core").InputSignal<LegendeDeRepartition>;
+  readonly epaisseur: import("@angular/core").InputSignal<EpaisseurDeRepartition>;
+  protected readonly lues: import("@angular/core").Signal<readonly PartLue[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRepartition, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRepartition, "st-repartition", never, {
+    "parts": {
+      "alias": "parts";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "devise": {
+      "alias": "devise";
+      "required": false;
+      "isSignal": true;
+    };
+    "legende": {
+      "alias": "legende";
+      "required": false;
+      "isSignal": true;
+    };
+    "epaisseur": {
+      "alias": "epaisseur";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+
+export {};