@starterlib/ui 0.7.2 → 0.9.0

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

@@ -0,0 +1,916 @@
+import { ApiError, EtatDeCeremonie, LectureDeCeremonie, MoyenDeCeremonie, TonSemantique } from "@starterlib/util";
+import * as i0 from "@angular/core";
+import { InjectionToken, Signal } from "@angular/core";
+import { AnnonceLocale, DispositionDActions, EtapeDeParcours, Icone, NiveauDeTitre, OrientationDeParcours } from "@starterlib/ui";
+import { ErreurAffichable } from "@starterlib/ui/saisie";
+/**
+ * Un refus du serveur, en banniere, au-dessus de ce qu'il refuse (lot 261) : un virement (plafond,
+ * solde), une demande KYC, une connexion. Le patron que chaque formulaire recopiait (`id-refus`).
+ *
+ * ```html
+ * @if (refus(); as erreur) {
+ *   <st-refusal
+ *     [erreur]="erreur"
+ *     [message]="t('erreurs.' + erreur.code, erreur.arguments)"
+ *     [codeInconnu]="!codesConnus.has(erreur.code)"
+ *     [rejeuEnCours]="envoiEnCours()"
+ *     (rejeu)="envoyer()"
+ *     (rechargement)="recharger()"
+ *   />
+ * }
+ * ```
+ *
+ * - Le MESSAGE est traduit par l'application depuis le CODE stable, jamais la prose du serveur.
+ * - Le ton suit la table de `@starterlib/util` (`varianteDErreur`) : un refus (400, 403, 404...) est
+ *   un `danger` ; ce qui se regle sans rien changer (hors ligne, 429, panne passagere, conflit de
+ *   version) est un `avertissement`.
+ * - Un 429 affiche son decompte (`Retry-After`) ; « Reessayer » reste focalisable et indisponible
+ *   jusqu'a sa fin, la phrase du decompte pour raison (D39), puis `(attenteTerminee)`.
+ * - Un conflit de version (409) offre « Recharger » (`(rechargement)`), jamais « Reessayer » : la
+ *   meme requete echouerait encore.
+ * - `rejeuEnCours` et `rechargementEnCours` : l'application a relance la requete. Le bouton attend
+ *   (`aria-busy`, indicateur differe) et avale les clics, comme le rejeu de `st-error` : un second
+ *   clic ne repart pas (audit UI du 2026-09-27, D-7).
+ * - `codeInconnu` : l'application n'a pas de message pour ce code ; le code et la trace s'affichent,
+ *   copiables, pour le support.
+ * - Le focus va a la banniere a chaque NOUVEAU refus (une fois) : au clavier, l'envoi qui a echoue
+ *   se sait. Jamais un toast pour une erreur.
+ *
+ * ⚠️ **C'est le focus qui annonce, et lui seul** (comme `st-error-summary`). Le composant fournit
+ * `REGION_VIVANTE_PARENTE` a sa banniere, qui ne pose alors ni `alert` ni `status` : region vivante
+ * ET cible du focus, elle etait lue deux fois, a son apparition puis a l'arrivee du focus (audit
+ * UI du 2026-09-27, D-18). En `viewProviders` : les actions que l'application projette gardent leur
+ * propre comportement.
+ */
+export declare class StRefusal {
+  private readonly injecteur;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  readonly erreur: import("@angular/core").InputSignal<ApiError>;
+  /** Deja traduit par l'application, depuis le code. */
+  readonly message: import("@angular/core").InputSignal<string>;
+  /** `null` : « Hors connexion » hors ligne, sinon le message seul. */
+  readonly titre: import("@angular/core").InputSignal<string | null>;
+  /** L'application n'a pas de message pour ce code : le code et la trace, pour le support. */
+  readonly codeInconnu: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le rejeu est parti : son bouton attend et avale les clics. */
+  readonly rejeuEnCours: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le rechargement est parti : son bouton attend et avale les clics. */
+  readonly rechargementEnCours: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly rejeu: import("@angular/core").OutputEmitterRef<void>;
+  readonly rechargement: import("@angular/core").OutputEmitterRef<void>;
+  /** L'attente imposee par un 429 est finie. */
+  readonly attenteTerminee: import("@angular/core").OutputEmitterRef<void>;
+  private readonly banniere;
+  private readonly decompte;
+  protected readonly variante: import("@angular/core").Signal<import("@starterlib/util").VarianteDErreur>;
+  private readonly rejouableSelonLaTable;
+  protected readonly ton: import("@angular/core").Signal<"avertissement" | "danger">;
+  protected readonly titreLu: import("@angular/core").Signal<string | null>;
+  /** Les secondes d'un 429, quand le serveur les donne. */
+  protected readonly attente: import("@angular/core").Signal<number | null>;
+  private readonly attenteFinie;
+  /** « Reessayer » : un 429 sans attente connue ne le propose pas (on ne sait pas quand). */
+  protected readonly rejouable: import("@angular/core").Signal<boolean>;
+  protected readonly enAttente: import("@angular/core").Signal<boolean>;
+  protected readonly raisonDuRejeu: import("@angular/core").Signal<string | null>;
+  constructor();
+  protected finDeLAttente(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRefusal, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRefusal, "st-refusal", never, {
+    "erreur": {
+      "alias": "erreur";
+      "required": true;
+      "isSignal": true;
+    };
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "codeInconnu": {
+      "alias": "codeInconnu";
+      "required": false;
+      "isSignal": true;
+    };
+    "rejeuEnCours": {
+      "alias": "rejeuEnCours";
+      "required": false;
+      "isSignal": true;
+    };
+    "rechargementEnCours": {
+      "alias": "rechargementEnCours";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "rejeu": "rejeu";
+    "rechargement": "rechargement";
+    "attenteTerminee": "attenteTerminee";
+  }, never, ["[actions]"], true, never>;
+}
+/** Comment s'est fini le parcours. `partiel` : une part executee, une part refusee. */
+export type IssueDeParcours = 'succes' | 'attente' | 'echec' | 'partiel';
+/** `page` : la fin d'un parcours, titre de page ; `compacte` : une issue dans une carte. */
+export type DispositionDIssue = 'page' | 'compacte';
+/**
+ * L'issue d'un parcours (lot 261) : virement envoye, dossier depose, demande en attente d'un second
+ * signataire, virement refuse. `st-empty` et `st-error` disent l'etat d'un BLOC ; celle-ci dit la
+ * fin d'un PARCOURS : son titre, sa reference, ce qui suit et les actions.
+ *
+ * ```html
+ * <st-outcome
+ *   issue="succes"
+ *   titre="Virement envoye"
+ *   precision="Il sera execute le 28 septembre."
+ *   [reference]="accuse.reference"
+ *   [horodatage]="accuse.recuLe"
+ * >
+ *   <st-amount-summary recapitulatif legende="Recapitulatif" legendeMasquee [lignes]="lignes" />
+ *   <a actions stLink routerLink="/operations">Voir mes operations</a>
+ *   <button actions stButton variante="primaire">Faire un autre virement</button>
+ * </st-outcome>
+ * ```
+ *
+ * - L'issue se dit par la FORME de l'icone et par un mot lu avant le titre (« Succes : »,
+ *   « Erreur : »), jamais par la couleur seule.
+ * - En `page`, le titre est le `h1` que vise `StNavigation` a l'arrivee ; jamais `role="alert"`,
+ *   meme en echec : c'est une page, pas une mutation.
+ * - Ordre du document : issue, precision, reference et horodatage, recapitulatif (`[recapitulatif]`),
+ *   suite (`[suite]`, « Et ensuite ? »), actions (`[actions]`, la principale en dernier).
+ * - En `compacte` (planche 8, 8.2) : l'icone et le titre en tete, une etiquette projetee
+ *   (`[etiquette]`) a la fin de la ligne, puis l'horodatage et un medaillon projete
+ *   (`[medaillon]`).
+ */
+export declare class StOutcome {
+  private readonly libelles;
+  readonly issue: import("@angular/core").InputSignal<IssueDeParcours>;
+  /** Deja traduit. */
+  readonly titre: import("@angular/core").InputSignal<string>;
+  readonly precision: import("@angular/core").InputSignal<string | null>;
+  /** La reference de l'operation, copiable ; `null` : aucune. */
+  readonly reference: import("@angular/core").InputSignal<string | null>;
+  /** `null` : « Reference de l'operation ». */
+  readonly etiquetteDeReference: import("@angular/core").InputSignal<string | null>;
+  /** Un instant ISO (reception, execution, scellement), dit en date et heure. */
+  readonly horodatage: import("@angular/core").InputSignal<string | null>;
+  /** Ce que l'horodatage date (« Horodatage de scellement ») ; `null` : l'instant seul. */
+  readonly etiquetteDHorodatage: import("@angular/core").InputSignal<string | null>;
+  /** `1` en page ; le niveau que la page donne a une issue compacte. */
+  readonly niveauDuTitre: import("@angular/core").InputSignal<NiveauDeTitre>;
+  readonly disposition: import("@angular/core").InputSignal<DispositionDIssue>;
+  protected readonly ton: import("@angular/core").Signal<TonSemantique>;
+  protected readonly icone: import("@angular/core").Signal<"horloge" | "badge-coche" | "bouclier-coche" | "cercle-alerte" | "cercle-coche" | "cercle-croix" | "cercle-info" | "cercle-question" | "cloche" | "epingle" | "etoile" | "grille" | "marque-page" | "octogone-alerte" | "triangle-alerte">;
+  /** Le mot de l'issue, lu avant le titre. */
+  protected readonly mot: import("@angular/core").Signal<string>;
+  protected readonly etiquetteDeReferenceLue: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StOutcome, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StOutcome, "st-outcome", never, {
+    "issue": {
+      "alias": "issue";
+      "required": true;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": true;
+      "isSignal": true;
+    };
+    "precision": {
+      "alias": "precision";
+      "required": false;
+      "isSignal": true;
+    };
+    "reference": {
+      "alias": "reference";
+      "required": false;
+      "isSignal": true;
+    };
+    "etiquetteDeReference": {
+      "alias": "etiquetteDeReference";
+      "required": false;
+      "isSignal": true;
+    };
+    "horodatage": {
+      "alias": "horodatage";
+      "required": false;
+      "isSignal": true;
+    };
+    "etiquetteDHorodatage": {
+      "alias": "etiquetteDHorodatage";
+      "required": false;
+      "isSignal": true;
+    };
+    "niveauDuTitre": {
+      "alias": "niveauDuTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[etiquette]", "[medaillon]", "[recapitulatif]", "[suite]", "[actions]"], true, never>;
+}
+/** L'etat d'une tache, tel que le serveur le garde. */
+export type StatutDeTache = 'a-faire' | 'en-cours' | 'terminee' | 'refusee' | 'bloquee';
+/** Une tache d'un dossier. Les textes sont deja traduits. */
+export interface TacheDeParcours {
+  readonly cle: string;
+  readonly titre: string;
+  /** Sous le titre, en discret : ce que la tache demande, un delai. */
+  readonly precision?: string;
+  /** Sa route (`routerLink`) ; absente, un bouton emet `ouverture`. */
+  readonly lien?: string | readonly unknown[];
+  readonly statut: StatutDeTache;
+  /** Le mot du statut (« Termine », « A faire ») : l'application le traduit. */
+  readonly libelleDuStatut: string;
+  /** Pourquoi une tache `bloquee` ne peut pas commencer : elle le dit, au lieu d'un lien eteint. */
+  readonly raison?: string;
+}
+/** Un groupe de taches sous son titre (« Identite », « Justificatifs »). */
+export interface SectionDeTaches {
+  readonly titre: string;
+  readonly cles: readonly string[];
+}
+interface TacheLue extends TacheDeParcours {
+  readonly ton: TonSemantique;
+  readonly icone: Icone;
+  readonly idDuStatut: string;
+  readonly idDeLaPrecision: string | null;
+  readonly decritPar: string;
+}
+/**
+ * La liste des taches d'un dossier (lot 262) : ouverture de compte, KYC, conformite d'un dossier.
+ * Chaque tache se reprend dans l'ordre que l'on veut ; son statut vient du serveur.
+ *
+ * ```html
+ * <st-task-list etiquette="Votre dossier" [taches]="taches" [sections]="sections" />
+ * ```
+ *
+ * - Une liste NATIVE (« 5 elements »), sous des titres de section si on les donne.
+ * - Chaque tache est un LIEN nomme par son titre ; son statut (`st-status-pill`, icone et mot) et
+ *   sa precision se lisent ensuite, par `aria-describedby`. Le lien couvre la ligne : 44 px.
+ * - Une tache `bloquee` n'est PAS un lien (pas meme un lien eteint) : un texte, et sa raison.
+ * - Le resume (« 2 taches sur 5 terminees ») n'est pas une region vivante.
+ */
+export declare class StTaskList {
+  private readonly libelles;
+  private readonly identifiants;
+  readonly taches: import("@angular/core").InputSignal<readonly TacheDeParcours[]>;
+  /** Le nom de la liste (sans sections) : « Votre dossier ». */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  /** `null` : une seule liste. */
+  readonly sections: import("@angular/core").InputSignal<readonly SectionDeTaches[] | null>;
+  /** Le niveau des titres de section. */
+  readonly niveauDuTitre: import("@angular/core").InputSignal<NiveauDeTitre>;
+  /** Le resume « 2 taches sur 5 terminees » en tete. */
+  readonly resume: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Une tache sans route : la page l'ouvre (dialogue, action). */
+  readonly ouverture: import("@angular/core").OutputEmitterRef<string>;
+  private readonly prefixe;
+  protected readonly lues: import("@angular/core").Signal<readonly TacheLue[]>;
+  protected readonly groupes: import("@angular/core").Signal<{
+    titre: string;
+    taches: TacheLue[];
+  }[] | null>;
+  protected readonly texteDuResume: import("@angular/core").Signal<string>;
+  protected readonly idDuTitre: (indice: number) => string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StTaskList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StTaskList, "st-task-list", never, {
+    "taches": {
+      "alias": "taches";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "sections": {
+      "alias": "sections";
+      "required": false;
+      "isSignal": true;
+    };
+    "niveauDuTitre": {
+      "alias": "niveauDuTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "resume": {
+      "alias": "resume";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "ouverture": "ouverture";
+  }, never, never, true, never>;
+}
+/** Ce qu'un `st-wizard` dit a l'etape qu'il projette : ou l'on en est, et le retour. */
+interface AssistantDeParcours {
+  /** L'etape en cours, a partir de 1. */
+  readonly numero: Signal<number>;
+  readonly total: Signal<number>;
+  /** Celle du `st-stepper` : horizontal, il se resume sous `md` en « Etape 2 sur 3 : Montant ». */
+  readonly orientation: Signal<OrientationDeParcours>;
+  /** La route de l'etape precedente ; `null` : un bouton, qui demande le retour. */
+  readonly retourVers: Signal<string | readonly unknown[] | null>;
+  /** Un retour existe : une route, ou une etape precedente. */
+  readonly retourPossible: Signal<boolean>;
+  demanderLeRetour(): void;
+}
+declare const ST_ASSISTANT: InjectionToken<AssistantDeParcours>;
+/**
+ * Un parcours par etapes (lot 262) : virement en trois etapes, ouverture de compte, enrolement
+ * d'un second facteur. Il rend le `st-stepper` (ou l'on en est) et projette l'etape en cours, un
+ * `st-wizard-step`.
+ *
+ * ```html
+ * <st-wizard libelle="Virement" [etapes]="etapes" [etape]="1" [retourVers]="['..', 'beneficiaire']">
+ *   <form [stForm]="montant" [envoyerAvec]="continuer">
+ *     <st-wizard-step titre="Montant">
+ *       <st-amount-field libelle="Montant" [formField]="montant.valeur" />
+ *     </st-wizard-step>
+ *   </form>
+ * </st-wizard>
+ * ```
+ *
+ * ⚠️ **Les etapes restent des ROUTES de l'application** : le composant ne navigue pas (aucun
+ * `Router` injecte). La route de chaque etape la rend, et `StNavigation` pose le focus sur son
+ * `h1` a l'arrivee. `retourVers` : la route de l'etape precedente ; sans elle, « Retour » est un
+ * bouton qui emet `(retour)`, et l'application decide.
+ *
+ * ⚠️ **La saisie survit au retour** : elle est detenue par l'application, le socle ne detruit
+ * rien. La garde `formulaireNonEnregistre` (`@starterlib/core`) sur la route du parcours est un
+ * PREALABLE : quitter le parcours en cours de saisie se confirme (A0811).
+ */
+export declare class StWizard implements AssistantDeParcours {
+  readonly etapes: import("@angular/core").InputSignal<readonly EtapeDeParcours[]>;
+  /** L'indice de l'etape en cours, a partir de zero (celui de `st-stepper`). */
+  readonly etape: import("@angular/core").InputSignal<number>;
+  /** Le nom visible du parcours (« Virement »). */
+  readonly libelle: import("@angular/core").InputSignal<string | null>;
+  /** Le nom de la liste des etapes, jamais affiche ; `null` : le libelle. */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  readonly orientation: import("@angular/core").InputSignal<OrientationDeParcours>;
+  /** La route de l'etape precedente ; `null` : « Retour » emet `(retour)`. */
+  readonly retourVers: import("@angular/core").InputSignal<string | readonly unknown[] | null>;
+  readonly retour: import("@angular/core").OutputEmitterRef<void>;
+  readonly total: import("@angular/core").Signal<number>;
+  readonly numero: import("@angular/core").Signal<number>;
+  readonly retourPossible: import("@angular/core").Signal<boolean>;
+  demanderLeRetour(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StWizard, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StWizard, "st-wizard", never, {
+    "etapes": {
+      "alias": "etapes";
+      "required": true;
+      "isSignal": true;
+    };
+    "etape": {
+      "alias": "etape";
+      "required": true;
+      "isSignal": true;
+    };
+    "libelle": {
+      "alias": "libelle";
+      "required": false;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "retourVers": {
+      "alias": "retourVers";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "retour": "retour";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Une etape d'un `st-wizard` (lot 262) : son titre, son contenu, ses actions.
+ *
+ * ```html
+ * <st-wizard-step titre="Verification" derniere
+ *   avertissement="Une fois confirme, le virement ne pourra plus etre annule.">
+ *   <st-review-list ... />
+ * </st-wizard-step>
+ * ```
+ *
+ * - Le titre est le `h1` de la page : « Etape 2 sur 3 : Montant » se LIT (le compte avant le
+ *   nom), « Etape 2 sur 3 » se voit en surtitre au-dessus de « Montant ».
+ * - Les actions (`st-form-actions`) : « Retour » d'abord dans l'ordre du document, puis
+ *   « Continuer », l'action principale, en `submit` : l'etape vit dans le formulaire de la page.
+ * - ⚠️ La derniere etape dit « Confirmer », jamais « Continuer », et son `avertissement` dit ce qui
+ *   ne pourra plus etre annule (WCAG 3.3.4) ; son absence est signalee en developpement, comme une
+ *   seconde action principale projetee. L'avertissement DECRIT « Confirmer » (`aria-describedby`) :
+ *   dit avant le bouton dans l'ordre du document, il etait saute par qui tabule droit dessus (audit
+ *   UI du 2026-09-27, D-33).
+ */
+export declare class StWizardStep {
+  private readonly assistant;
+  private readonly element;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  readonly titre: import("@angular/core").InputSignal<string>;
+  /** `1` : l'etape est la page ; un autre niveau pour une etape montree dans une page. */
+  readonly niveauDuTitre: import("@angular/core").InputSignal<NiveauDeTitre>;
+  /** La derniere etape : « Confirmer », et l'avertissement d'irrevocabilite. */
+  readonly derniere: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Ce qui ne pourra plus etre annule, dit avant « Confirmer ». */
+  readonly avertissement: import("@angular/core").InputSignal<string | null>;
+  /** `null` : « Continuer ». */
+  readonly libelleContinuer: import("@angular/core").InputSignal<string | null>;
+  readonly chargement: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly indisponible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `pied` : une rangee a la fin de l'etape ; `collee` : la barre qui suit le defilement. */
+  readonly dispositionDesActions: import("@angular/core").InputSignal<DispositionDActions>;
+  protected readonly titreLu: import("@angular/core").Signal<string>;
+  protected readonly compte: import("@angular/core").Signal<string | null>;
+  protected readonly retourVers: import("@angular/core").Signal<string | readonly unknown[] | null>;
+  protected readonly orientation: import("@angular/core").Signal<import("@starterlib/ui").OrientationDeParcours | null>;
+  protected readonly retourPossible: import("@angular/core").Signal<boolean>;
+  protected readonly libelleDeLAction: import("@angular/core").Signal<string>;
+  /** L'avertissement d'irrevocabilite est-il montre ? Il decrit alors « Confirmer » (D-33). */
+  protected readonly avecAvertissement: import("@angular/core").Signal<boolean>;
+  protected readonly idDeLAvertissement: string;
+  constructor();
+  protected retourner(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StWizardStep, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StWizardStep, "st-wizard-step", never, {
+    "titre": {
+      "alias": "titre";
+      "required": true;
+      "isSignal": true;
+    };
+    "niveauDuTitre": {
+      "alias": "niveauDuTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "derniere": {
+      "alias": "derniere";
+      "required": false;
+      "isSignal": true;
+    };
+    "avertissement": {
+      "alias": "avertissement";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleContinuer": {
+      "alias": "libelleContinuer";
+      "required": false;
+      "isSignal": true;
+    };
+    "chargement": {
+      "alias": "chargement";
+      "required": false;
+      "isSignal": true;
+    };
+    "indisponible": {
+      "alias": "indisponible";
+      "required": false;
+      "isSignal": true;
+    };
+    "dispositionDesActions": {
+      "alias": "dispositionDesActions";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*", "[avantActions]", "[actions]"], true, never>;
+}
+/** Ce que `st-challenge` emet a l'envoi : le moyen, et le code tel que saisi (vide pour une cle). */
+export interface EnvoiDeCeremonie {
+  readonly moyen: MoyenDeCeremonie;
+  readonly code: string;
+}
+/**
+ * La ceremonie d'un second facteur ou d'une confirmation forte (lot 263) : connexion, virement,
+ * ajout de beneficiaire, changement de plafond. Le composant ne fait AUCUN appel reseau :
+ * l'application execute la ceremonie et lui dit ou elle en est.
+ *
+ * ```html
+ * <st-challenge
+ *   titre="Confirmez le virement"
+ *   description="Saisissez le code recu par SMS au 06 •• •• •• 42."
+ *   [ceremonie]="ceremonie()"
+ *   [autresMoyens]="['appareil', 'secours']"
+ *   [(moyen)]="moyen"
+ *   renvoyable
+ *   [renvoiDans]="30"
+ *   [chargement]="envoiEnCours()"
+ *   (envoi)="confirmer($event)"
+ *   (renvoi)="renvoyerLeCode()"
+ * >
+ *   <st-review-list operation [lignes]="recapitulatif()" />
+ * </st-challenge>
+ * ```
+ *
+ * - `[operation]` : pour une authentification forte (DSP2), le recapitulatif de ce que l'on
+ *   confirme (montant, beneficiaire), lu AVANT le champ et decrivant le groupe (lien dynamique).
+ * - Selon `moyen` : un `code` (un seul champ, `one-time-code`, jamais envoye a la longueur
+ *   atteinte, collage jamais bloque), un code de `secours` (espaces et tirets acceptes, jamais
+ *   tronques), une validation sur l'`appareil` (attente sans annonce par seconde, expiration
+ *   annoncee), une cle d'acces (`passkey` : le bouton lance la ceremonie, `navigator.credentials`
+ *   restant dans le geste de la personne, chez l'application).
+ * - `ceremonie` : la lecture du serveur (`versEtatDeCeremonie`, `StSession`). Un refus met
+ *   l'erreur sous le champ, dit les essais restants, annonce, et rend le focus au champ ; un
+ *   blocage s'affiche en `alert`, champ indisponible jusqu'a la fin du delai. Un NOUVEL objet par
+ *   reponse : deux refus de suite se disent deux fois. L'annonce ne double jamais le focus : les
+ *   essais restants decrivent le champ (`decritPar`), et le focus amene au champ lit l'erreur et
+ *   les essais, sans annonce ; deja sur le champ (Entree), rien n'est relu, et le refus entier
+ *   s'annonce (audit UI du 2026-09-27, D-20).
+ * - Le renvoi d'un code (`renvoyable`) attend `renvoiDans` secondes, 30 par defaut, a l'arrivee et
+ *   apres chaque renvoi ; `renvoiEnCours` fait attendre son bouton et avale les clics ; un nouveau
+ *   code demande s'annonce (audit UI du 2026-09-27, D-9).
+ * - « Utiliser un autre moyen » est un bouton, present meme en attente.
+ * - Dans un dialogue (`StDialog`, role `alertdialog`) : sans `titre`, le titre du dialogue nomme
+ *   la ceremonie ; « Annuler » (`annulable`) et Echap annulent l'operation, dit en toutes lettres
+ *   par `libelleDAnnulation`.
+ *
+ * ⚠️ Jamais dans un `<form>` : le composant porte le sien (un formulaire dans un autre est
+ * invalide, et Entree enverrait le mauvais).
+ */
+export declare class StChallenge {
+  private readonly injecteur;
+  private readonly hote;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  protected readonly annonce: AnnonceLocale;
+  private readonly identifiants;
+  protected readonly idDuTitre: string;
+  protected readonly idDeLOperation: string;
+  protected readonly idDesMoyens: string;
+  protected readonly idDesTentatives: string;
+  /** Le nom de la ceremonie, deja traduit ; `null` dans un dialogue, que son titre nomme. */
+  readonly titre: import("@angular/core").InputSignal<string | null>;
+  readonly niveauDuTitre: import("@angular/core").InputSignal<NiveauDeTitre>;
+  /** Ce qu'il faut faire, deja traduit (« Saisissez le code recu par SMS »). */
+  readonly description: import("@angular/core").InputSignal<string | null>;
+  readonly moyen: import("@angular/core").ModelSignal<MoyenDeCeremonie>;
+  /** Les AUTRES moyens offerts, sous « Utiliser un autre moyen ». */
+  readonly autresMoyens: import("@angular/core").InputSignal<readonly MoyenDeCeremonie[]>;
+  /** La lecture du serveur ; `null` : la premiere saisie (ou l'attente, pour `appareil`). */
+  readonly ceremonie: import("@angular/core").InputSignal<LectureDeCeremonie | null>;
+  readonly longueurDuCode: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Libelle du champ ; defaut : « Code de verification » (ou « Code de secours »). */
+  readonly libelleDuCode: import("@angular/core").InputSignal<string | null>;
+  readonly aideDuCode: import("@angular/core").InputSignal<string | null>;
+  /** Le code peut etre renvoye (SMS, courriel) ; pas un code d'application d'authentification. */
+  readonly renvoyable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Secondes avant le prochain renvoi possible ; `null` : 30 pour un code `renvoyable`. */
+  readonly renvoiDans: import("@angular/core").InputSignal<number | null>;
+  /** Le renvoi (code, ou nouvelle demande a l'appareil) est parti : son bouton attend. */
+  readonly renvoiEnCours: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Validite de la demande, en secondes : a son terme, la ceremonie `expire`. */
+  readonly expireDans: import("@angular/core").InputSignal<number | null>;
+  /** L'envoi, ou la ceremonie de la cle, est en cours. */
+  readonly chargement: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** « Faire confiance a cet appareil » : a la connexion seulement, jamais pour une operation. */
+  readonly proposerAppareilDeConfiance: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly appareilDeConfiance: import("@angular/core").ModelSignal<boolean>;
+  readonly annulable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** « Annuler le virement » plutot qu'« Annuler » : ce que l'on abandonne, en toutes lettres. */
+  readonly libelleDAnnulation: import("@angular/core").InputSignal<string | null>;
+  /** L'action principale ; defaut : « Confirmer ». */
+  readonly libelleDeLAction: import("@angular/core").InputSignal<string | null>;
+  readonly code: import("@angular/core").ModelSignal<string>;
+  /**
+   * Le focus au champ a l'arrivee (une etape qui apparait sur place : la connexion, un dialogue).
+   * Faux sur une route ou `StNavigation` vise deja le titre, et dans une page de demonstration.
+   */
+  readonly focusALArrivee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly envoi: import("@angular/core").OutputEmitterRef<EnvoiDeCeremonie>;
+  /** Un nouveau code, une nouvelle demande a l'appareil (non recue, ou expiree). */
+  readonly renvoi: import("@angular/core").OutputEmitterRef<void>;
+  readonly annulation: import("@angular/core").OutputEmitterRef<void>;
+  readonly expiration: import("@angular/core").OutputEmitterRef<void>;
+  private readonly champDuCode;
+  private readonly champDeSecours;
+  private readonly operation;
+  /**
+   * La lecture qui vaut pour le moyen en cours : quand seul le moyen change, celle du precedent ne
+   * s'applique plus (un refus du code ne se montre pas sur le code de secours).
+   */
+  private readonly lecture;
+  /** L'etat montre : celui du serveur, sauf quand un delai finit ici (expiration, blocage). */
+  protected readonly etat: import("@angular/core").WritableSignal<EtatDeCeremonie>;
+  protected readonly bloque: import("@angular/core").Signal<boolean>;
+  protected readonly expiree: import("@angular/core").Signal<boolean>;
+  protected readonly horsService: import("@angular/core").Signal<boolean>;
+  protected readonly avecCode: import("@angular/core").Signal<boolean>;
+  protected readonly tentativesRestantes: import("@angular/core").Signal<number | null>;
+  /**
+   * Les essais restants DECRIVENT le champ (`aria-describedby`), lus apres l'aide et avant
+   * l'erreur : amene au champ, le focus lit l'erreur et les essais (audit UI du 2026-09-27, D-20).
+   * Relies tant qu'ils s'affichent (la meme condition que le gabarit) : un identifiant absent de la
+   * page ferait ignorer toute la description par certains lecteurs d'ecran.
+   */
+  protected readonly descriptionsDuChamp: import("@angular/core").Signal<readonly string[]>;
+  /** Les secondes du blocage, quand le serveur les donne. */
+  protected readonly attenteDuBlocage: import("@angular/core").Signal<number | null>;
+  protected readonly libelleDuChamp: import("@angular/core").Signal<string>;
+  protected readonly libelleDuBouton: import("@angular/core").Signal<string>;
+  /**
+   * Le delai de renvoi lu : celui de l'application, sinon 30 s pour un code renvoyable (D-9). Le
+   * defaut ne vaut que pour le moyen `code`, qui seul porte le bouton de renvoi et son decompte :
+   * pose sur l'appareil, il avalerait la nouvelle demande (`demandeNonRecue`) sans rien en dire.
+   */
+  protected readonly delaiDeRenvoi: import("@angular/core").Signal<number | null>;
+  /**
+   * L'instant ou le renvoi redevient possible (`null` : il l'est), relance a chaque renvoi : une
+   * meme duree ne change pas l'entree, un nouvel instant si. La phrase du decompte est la raison
+   * du bouton indisponible (D39).
+   */
+  protected readonly finDuDelaiDeRenvoi: import("@angular/core").WritableSignal<number | null>;
+  protected readonly renvoiEnAttente: import("@angular/core").Signal<boolean>;
+  /** L'instant ou la demande expire (`null` : sans delai), relance a chaque nouvelle demande. */
+  protected readonly finDeValidite: import("@angular/core").WritableSignal<number | null>;
+  private readonly decompteDuRenvoi;
+  protected readonly raisonDuRenvoi: import("@angular/core").Signal<string | null>;
+  protected readonly moyensOuverts: import("@angular/core").WritableSignal<boolean>;
+  protected readonly autres: import("@angular/core").Signal<MoyenDeCeremonie[]>;
+  /** Un envoi a ete tente : les erreurs de forme se montrent. */
+  private readonly tente;
+  /** Le code au moment du refus : l'erreur du serveur tombe des qu'il change. */
+  private readonly codeAuRefus;
+  protected readonly erreurs: import("@angular/core").Signal<readonly ErreurAffichable[]>;
+  protected readonly erreursVisibles: import("@angular/core").Signal<boolean>;
+  protected readonly avecOperation: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  /**
+   * Ce qu'un refus dit a voix haute : seulement ce que le focus ne dira pas (audit UI du
+   * 2026-09-27, D-20). Amene au champ, le focus lit sa description : l'erreur et les essais
+   * restants, relies par `aria-describedby` ; rien a annoncer. Deja sur le champ (envoi par
+   * Entree), le focus ne relit rien : le refus entier. Sans champ (appareil, cle d'acces), le refus
+   * du moyen, tel qu'il s'affiche ; le code refuse n'y avait pas de sens.
+   */
+  private annonceDuRefus;
+  protected surEnvoi(evenement: Event): void;
+  protected utiliserLaCle(): void;
+  protected renvoyer(): void;
+  /**
+   * Un autre moyen : le bouton choisi disparait avec la liste, et le focus va a ce qui porte le
+   * nouveau moyen (son champ, ou son bouton), jamais au corps de la page.
+   */
+  protected choisir(moyen: MoyenDeCeremonie): void;
+  protected finDuRenvoi(): void;
+  protected finDeLaDemande(): void;
+  /** Le blocage est leve : un nouvel essai est possible, avec un champ vide. */
+  protected finDuBlocage(): void;
+  private focaliserLeChamp;
+  /** L'element natif du champ (code, ou code de secours) ; `null` pour l'appareil et la cle. */
+  private saisieDuCode;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StChallenge, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StChallenge, "st-challenge", never, {
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "niveauDuTitre": {
+      "alias": "niveauDuTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "moyen": {
+      "alias": "moyen";
+      "required": false;
+      "isSignal": true;
+    };
+    "autresMoyens": {
+      "alias": "autresMoyens";
+      "required": false;
+      "isSignal": true;
+    };
+    "ceremonie": {
+      "alias": "ceremonie";
+      "required": false;
+      "isSignal": true;
+    };
+    "longueurDuCode": {
+      "alias": "longueurDuCode";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDuCode": {
+      "alias": "libelleDuCode";
+      "required": false;
+      "isSignal": true;
+    };
+    "aideDuCode": {
+      "alias": "aideDuCode";
+      "required": false;
+      "isSignal": true;
+    };
+    "renvoyable": {
+      "alias": "renvoyable";
+      "required": false;
+      "isSignal": true;
+    };
+    "renvoiDans": {
+      "alias": "renvoiDans";
+      "required": false;
+      "isSignal": true;
+    };
+    "renvoiEnCours": {
+      "alias": "renvoiEnCours";
+      "required": false;
+      "isSignal": true;
+    };
+    "expireDans": {
+      "alias": "expireDans";
+      "required": false;
+      "isSignal": true;
+    };
+    "chargement": {
+      "alias": "chargement";
+      "required": false;
+      "isSignal": true;
+    };
+    "proposerAppareilDeConfiance": {
+      "alias": "proposerAppareilDeConfiance";
+      "required": false;
+      "isSignal": true;
+    };
+    "appareilDeConfiance": {
+      "alias": "appareilDeConfiance";
+      "required": false;
+      "isSignal": true;
+    };
+    "annulable": {
+      "alias": "annulable";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDAnnulation": {
+      "alias": "libelleDAnnulation";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDeLAction": {
+      "alias": "libelleDeLAction";
+      "required": false;
+      "isSignal": true;
+    };
+    "code": {
+      "alias": "code";
+      "required": false;
+      "isSignal": true;
+    };
+    "focusALArrivee": {
+      "alias": "focusALArrivee";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "moyen": "moyenChange";
+    "appareilDeConfiance": "appareilDeConfianceChange";
+    "code": "codeChange";
+    "envoi": "envoi";
+    "renvoi": "renvoi";
+    "annulation": "annulation";
+    "expiration": "expiration";
+  }, never, ["[operation]"], true, never>;
+}
+/**
+ * Les codes de secours d'un second facteur (lot 263), montres UNE fois apres leur generation
+ * (`POST /api/v1/identity/mfa/recovery-codes`), puis leur compteur.
+ *
+ * ```html
+ * <st-recovery-codes [codes]="codes()" [(confirme)]="enregistres" (confirmation)="suite()" />
+ * <!-- ensuite, sur l'ecran de securite du compte : -->
+ * <st-recovery-codes [restants]="etat().recoveryCodesRemaining" (regeneration)="regenerer()" />
+ * ```
+ *
+ * - Un avertissement (usage unique, hors ligne, plus jamais affiches), puis la liste ORDONNEE des
+ *   codes, chacun copiable (`st-code`, « Copier : Code de secours 3 ») ; « Copier tous les
+ *   codes », « Telecharger » (un fichier texte fabrique ici, jamais stocke) et « Imprimer » (seuls
+ *   les codes s'impriment).
+ * - L'engagement passe par une case nommee (« J'ai enregistre ces codes en lieu sur ») : l'action
+ *   principale reste indisponible, sa raison dite, tant qu'elle n'est pas cochee.
+ * - `restants` : le compteur, et « Generer de nouveaux codes » (`(regeneration)`). Regenerer
+ *   invalide les anciens : l'application le confirme (`StDialog.confirmer`, ton danger) et
+ *   redemande l'identite (le service l'exige) AVANT d'appeler le serveur. `regenerationEnCours`
+ *   fait attendre le bouton et avale les clics : un double clic regenerait deux fois, et le second
+ *   jeu invalidait le premier sous les yeux de la personne (audit UI du 2026-09-27, D-8).
+ * - Le telechargement se dit, fichier nomme (`fichierTelecharge`) : le navigateur ne le dit pas
+ *   toujours, et rien ne change a l'ecran.
+ *
+ * ⚠️ **Les codes ne sortent jamais du composant** : aucune sortie ne porte leur valeur, aucune
+ * trace ne les ecrit. Le presse-papiers est la seule exception, voulue : le geste qui les range
+ * dans un gestionnaire de mots de passe (a l'inverse de `st-copy-button`, qui refuse les secrets).
+ */
+export declare class StRecoveryCodes {
+  private readonly document;
+  private readonly destruction;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  protected readonly annonce: AnnonceLocale;
+  /** Les codes, tels que le serveur les rend ; affiches une fois, jamais emis. */
+  readonly codes: import("@angular/core").InputSignal<readonly string[]>;
+  /** Le compteur : les codes encore utilisables ; `null` : la liste des codes. */
+  readonly restants: import("@angular/core").InputSignal<number | null>;
+  /** La regeneration est partie : le bouton attend, et un second clic ne repart pas. */
+  readonly regenerationEnCours: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** En tete du fichier telecharge (« Codes de secours de marie@exemple.fr »), deja traduit. */
+  readonly enTeteDuFichier: import("@angular/core").InputSignal<string | null>;
+  readonly nomDuFichier: import("@angular/core").InputSignal<string>;
+  /** L'action principale ; defaut : « Continuer ». */
+  readonly libelleDeLAction: import("@angular/core").InputSignal<string | null>;
+  readonly confirme: import("@angular/core").ModelSignal<boolean>;
+  /** Les codes sont enregistres, la personne poursuit. */
+  readonly confirmation: import("@angular/core").OutputEmitterRef<void>;
+  /** Sorties SANS la valeur des codes : ce qui a ete fait, jamais ce qui a ete copie. */
+  readonly copie: import("@angular/core").OutputEmitterRef<void>;
+  readonly telechargement: import("@angular/core").OutputEmitterRef<void>;
+  readonly impression: import("@angular/core").OutputEmitterRef<void>;
+  readonly regeneration: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly tousLesCodes: import("@angular/core").Signal<string>;
+  protected readonly raisonDeLAttente: import("@angular/core").Signal<string>;
+  /** Le compteur alerte quand il ne reste presque plus de codes. */
+  protected readonly tonDuCompteur: import("@angular/core").Signal<"avertissement" | "danger" | "neutre">;
+  constructor();
+  protected copier(): void;
+  /** Garde du double clic : `chargement` avale deja les clics du bouton, la methode aussi. */
+  protected regenerer(): void;
+  /**
+   * Un fichier texte fabrique ici, puis oublie : ni stockage, et une adresse revoquee apres
+   * `DELAI_AVANT_REVOCATION`, jamais dans la tache du clic. La minuterie survit a la destruction :
+   * annulee, elle laisserait l'adresse vivante jusqu'au depart de la page ; remplacee par une
+   * revocation immediate, elle rendrait le defaut qu'elle corrige a l'application qui quitte la
+   * vue sur `telechargement`.
+   */
+  protected telecharger(): void;
+  /**
+   * Seuls les codes s'impriment : la page entiere, hors de leur lignee, disparait a l'impression
+   * (`data-st-impression-exclusive`, feuille des jetons), le temps du dialogue du navigateur.
+   */
+  protected imprimer(): void;
+  protected confirmer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRecoveryCodes, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRecoveryCodes, "st-recovery-codes", never, {
+    "codes": {
+      "alias": "codes";
+      "required": false;
+      "isSignal": true;
+    };
+    "restants": {
+      "alias": "restants";
+      "required": false;
+      "isSignal": true;
+    };
+    "regenerationEnCours": {
+      "alias": "regenerationEnCours";
+      "required": false;
+      "isSignal": true;
+    };
+    "enTeteDuFichier": {
+      "alias": "enTeteDuFichier";
+      "required": false;
+      "isSignal": true;
+    };
+    "nomDuFichier": {
+      "alias": "nomDuFichier";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDeLAction": {
+      "alias": "libelleDeLAction";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirme": {
+      "alias": "confirme";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "confirme": "confirmeChange";
+    "confirmation": "confirmation";
+    "copie": "copie";
+    "telechargement": "telechargement";
+    "impression": "impression";
+    "regeneration": "regeneration";
+  }, never, never, true, never>;
+}
+
+export {};