@starterlib/ui 0.7.2 → 0.9.0

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

@@ -0,0 +1,317 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Provider, Signal } from "@angular/core";
+import { AnnonceLocale, CatalogueDuPointDEntree } from "@starterlib/ui";
+/**
+ * Le modele d'un fil de messages (lot 266) : ce que l'application affiche, deja lu de son API.
+ * Le corps est du TEXTE BRUT : aucun HTML n'entre ni ne sort de la messagerie (SEC-6, X11).
+ */
+/** `envoi` : parti, sans reponse encore ; `echec` : refuse ou perdu, a reprendre. */
+export type StatutDeMessage = 'envoi' | 'envoye' | 'lu' | 'echec';
+/** `interne` : une note que seuls les agents voient ; `systeme` : un evenement du dossier. */
+export type NatureDeMessage = 'ordinaire' | 'interne' | 'systeme';
+export interface PieceJointeDeMessage {
+  readonly nom: string;
+  /** Le type EN CLAIR (« PDF », « JPG »), jamais un type MIME : `st-attachment` le dit tel quel. */
+  readonly type: string;
+  readonly taille?: number | null;
+  /** L'adresse de telechargement, sur l'origine du BFF. */
+  readonly lien?: string | null;
+}
+export interface MessageAffiche {
+  /** Identite stable : elle suit le message, et la reprise d'un envoi la rend. */
+  readonly id: string;
+  /** Le nom affiche de l'auteur ; ignore pour un message `systeme`. */
+  readonly auteur: string;
+  /** Sa fonction (« Conseillere »), jamais un droit technique. */
+  readonly precision?: string | null;
+  readonly avatar?: string | null;
+  /** Un instant, avec son decalage (« 2026-09-12T14:02:00+02:00 »). */
+  readonly envoyeLe: string;
+  /** Texte brut ; une ligne vide separe deux paragraphes. */
+  readonly corps: string;
+  /** Le message de la personne connectee. */
+  readonly soi?: boolean;
+  readonly nature?: NatureDeMessage;
+  readonly statut?: StatutDeMessage | null;
+  readonly piecesJointes?: readonly PieceJointeDeMessage[];
+}
+/** Ce que le composeur remet a l'application ; la cle d'idempotence est la sienne. */
+export interface EnvoiDeMessage {
+  readonly texte: string;
+  readonly fichiers: readonly File[];
+}
+/**
+ * Les libelles de la messagerie (lot 266) : le PREMIER catalogue par point d'entree (AD-10, D147).
+ * Ils se chargent avec `@starterlib/ui/messagerie`, jamais au tronc que l'hote peint au premier
+ * ecran ; la langue suit celle du dictionnaire du tronc (`ST_LIBELLES`, sa `locale`).
+ */
+export interface LibellesMessagerie {
+  readonly afficherLesMessagesPrecedents: string;
+  /** Dit une fois, hors du fil, quand des messages plus anciens entrent en tete (D-19). */
+  readonly messagesPrecedentsAffiches: (nombre: number) => string;
+  /** Le nom d'un message : son auteur et son heure (« Marie Dupont, 12/09 14:02 »). */
+  readonly messageDe: (auteur: string, quand: string) => string;
+  readonly noteInterne: string;
+  readonly envoiEnCours: string;
+  readonly envoye: string;
+  readonly lu: string;
+  readonly echecDeLEnvoi: string;
+  readonly reessayer: string;
+  /** Le nom du bouton de reprise : il dit QUEL message (« ... du 12/09 14:02 »). */
+  readonly reessayerLEnvoiDu: (quand: string) => string;
+  readonly piecesJointes: string;
+  readonly votreMessage: string;
+  readonly joindreDesFichiers: string;
+  readonly envoyer: string;
+  /** L'aide du composeur : le raccourci d'envoi. */
+  readonly raccourciDEnvoi: string;
+}
+export declare const LIBELLES_MESSAGERIE_FR: LibellesMessagerie;
+export declare const LIBELLES_MESSAGERIE_EN: LibellesMessagerie;
+/**
+ * Les catalogues de la messagerie par langue (sous-etiquette primaire : `fr`, `en`). Une application
+ * qui ajoute une langue au dictionnaire du tronc ajoute la sienne ici, par
+ * `fournirLibellesMessagerie({ de: ... })`.
+ */
+export declare const ST_LIBELLES_MESSAGERIE: InjectionToken<Readonly<Record<string, LibellesMessagerie>>>;
+/** Ajoute (ou remplace) des catalogues de la messagerie, par langue. */
+export declare function fournirLibellesMessagerie(catalogues: Readonly<Record<string, LibellesMessagerie>>): Provider;
+/**
+ * Le catalogue de la langue du dictionnaire du tronc ; le francais quand la langue n'en a pas, un
+ * repli signale en developpement (audit du 2026-09-27, D-29). A appeler dans un contexte
+ * d'injection.
+ */
+export declare function libellesDeLaMessagerie(): Signal<LibellesMessagerie>;
+/**
+ * Le catalogue de la messagerie ET la langue de son repli (`catalogueDuPointDEntree`) : `lang` de
+ * ce qu'il ecrit seul (audit du 2026-09-27, D-29). A appeler dans un contexte d'injection.
+ */
+export declare function catalogueDeLaMessagerie(): Signal<CatalogueDuPointDEntree<LibellesMessagerie>>;
+/**
+ * Un message d'un fil (lot 266) : un `article` NOMME par son auteur et son heure (« Marie Dupont,
+ * 12/09 14:02 »), l'auteur (`st-person`), l'heure (`time`), le corps en paragraphes, les pieces
+ * jointes (`st-attachment`), le statut de l'envoi.
+ *
+ * - Le corps est du TEXTE BRUT, interpole : « <img onerror> » ou « javascript: » s'affichent tels
+ *   quels (SEC-6, X11). Une ligne vide separe deux paragraphes ; aucun lien n'est fabrique.
+ * - `echec` : un bouton « Reessayer », nomme par le message qu'il reprend (« Reessayer l'envoi du
+ *   message du 12/09 14:02 ») ; la reprise emet l'identite du message, la cle d'idempotence reste
+ *   celle de l'application. Pendant l'envoi qu'il relance, le MEME bouton reste, en chargement :
+ *   il garde le focus ; parti avec l'envoi abouti, le focus va a l'article, jamais au corps de la
+ *   page (audit UI du 2026-09-27, D-24, modele de `st-file-upload`).
+ * - Les statuts ne parlent pas (`aria-live="off"`) : dans le fil vivant, « Envoye » puis « Lu »
+ *   seraient des insertions lues, pour chaque message. L'echec seul parle (D-19).
+ * - `interne` : une note que seuls les agents voient, dite en toutes lettres ; `systeme` : un
+ *   evenement du dossier, centre, sans auteur.
+ * - Catalogue retombe sur le francais : `lang="fr"` sur ce qu'il ecrit seul (statuts, note
+ *   interne, reprise), jamais sur le corps ni sur l'auteur (audit du 2026-09-27, D-29).
+ */
+export declare class StMessage {
+  private readonly locale;
+  private readonly fuseau;
+  private readonly element;
+  private readonly document;
+  private readonly injecteur;
+  private readonly article;
+  private readonly catalogue;
+  protected readonly libelles: Signal<LibellesMessagerie>;
+  /**
+   * `fr` quand le catalogue retombe sur le francais, `null` sinon : le `lang` de ce qu'il ecrit
+   * seul. Le nom de l'article et la liste des pieces jointes melent le catalogue a des donnees
+   * (l'auteur, les fichiers) : ils gardent la langue de la page (D-29).
+   */
+  protected readonly langueDeRepli: Signal<string | null>;
+  readonly message: import("@angular/core").InputSignal<MessageAffiche>;
+  /** La reprise d'un envoi en echec : l'identite du message. */
+  readonly reessai: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly nature: Signal<NatureDeMessage>;
+  protected readonly statut: Signal<StatutDeMessage | null>;
+  /** La reprise demandee par CE bouton, le temps de l'envoi qu'elle relance (D-24). */
+  private readonly repriseDemandee;
+  /** « Reessayer » : a l'echec, puis pendant la reprise qu'il a lancee, en chargement. */
+  protected readonly repriseVisible: Signal<boolean>;
+  constructor();
+  private readonly instant;
+  /** « 14:02 » : le jour est dit par le fil. */
+  protected readonly heure: Signal<string>;
+  /** « 12/09 14:02 » : le nom du message et celui de sa reprise disent le jour. */
+  protected readonly quand: Signal<string>;
+  protected readonly nom: Signal<string>;
+  /**
+   * Les paragraphes du corps : separes par une ligne vide, les retours simples gardes. Le corps
+   * vient de l'autre partie : sans commande de direction, chaque paragraphe isole (`dir="auto"`),
+   * un IBAN ou un montant cite ne s'affiche pas retourne (audit du 2026-09-27, A-2).
+   */
+  protected readonly paragraphes: Signal<string[]>;
+  protected readonly pieces: Signal<readonly PieceJointeDeMessage[]>;
+  /** Le bouton reste, et tourne, pendant l'envoi qu'il relance (D-24). */
+  protected reprendre(): void;
+  private formater;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMessage, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMessage, "st-message", never, {
+    "message": {
+      "alias": "message";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {
+    "reessai": "reessai";
+  }, never, never, true, never>;
+}
+/** Les messages d'un meme jour, dans l'ordre du fil. */
+interface JourDuFil {
+  /** `2026-09-12`, dans le fuseau de l'application. */
+  readonly jour: string;
+  /** « samedi 12 septembre 2026 ». */
+  readonly titre: string;
+  readonly messages: readonly MessageAffiche[];
+}
+/**
+ * Le fil d'une conversation (lot 266) : les messages d'un dossier, groupes par jour.
+ *
+ * ```html
+ * <st-message-thread etiquette="Echanges avec votre conseillere" [messages]="messages()"
+ *   [precedents]="aDesPrecedents()" (chargerPrecedents)="chargerPlusTot()"
+ *   (reessai)="renvoyer($event)" />
+ * ```
+ *
+ * - Vivant (defaut) : une region `role="log"` NOMMEE : un message ajoute s'annonce poliment, sans
+ *   voler le focus. Fige (`fige`, un historique clos) : une liste ordonnee, sans region vivante.
+ * - Les jours se separent par leur date longue ; chaque message dit son jour dans son nom.
+ * - « Afficher les messages precedents » en tete quand il y en a (`precedents`) ; le chargement
+ *   appartient a l'application, qui le dit par `chargementDesPrecedents` : le bouton tourne, et le
+ *   fil reste occupe (`aria-busy`) jusqu'a l'insertion EN TETE, que le `log` lirait sinon comme
+ *   des messages nouveaux. Leur nombre se dit une fois (« 2 messages precedents affiches ») ; le
+ *   bouton parti avec les derniers, le focus va au premier message (audit UI du 2026-09-27, D-19).
+ * - Catalogue retombe sur le francais : `lang="fr"` sur ce bouton et sur cette annonce, qu'il
+ *   ecrit seul ; jamais sur le fil, que nomme l'application (audit du 2026-09-27, D-29).
+ */
+export declare class StMessageThread {
+  private readonly locale;
+  private readonly fuseau;
+  private readonly element;
+  private readonly document;
+  private readonly injecteur;
+  private readonly catalogue;
+  protected readonly libelles: Signal<LibellesMessagerie>;
+  /** `fr` quand le catalogue retombe sur le francais, `null` sinon (D-29). */
+  protected readonly langueDeRepli: Signal<string | null>;
+  /** Le nom du fil, deja traduit (« Echanges avec votre conseillere »). */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  /** Du plus ancien au plus recent. */
+  readonly messages: import("@angular/core").InputSignal<readonly MessageAffiche[]>;
+  /** Un historique clos : une liste, sans region vivante. */
+  readonly fige: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Des messages plus anciens existent : le bouton de chargement se montre. */
+  readonly precedents: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Des messages plus anciens sont demandes (apres `chargerPrecedents`) : le bouton le dit
+   * (`chargement`), et le fil porte `aria-busy` (D-19).
+   */
+  readonly chargementDesPrecedents: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly chargerPrecedents: import("@angular/core").OutputEmitterRef<void>;
+  /** La reprise d'un envoi en echec : l'identite du message. */
+  readonly reessai: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly annonce: AnnonceLocale;
+  /** Des messages viennent d'entrer EN TETE : le fil reste occupe, le temps d'etre relu. */
+  private readonly insertionEnCours;
+  protected readonly occupe: Signal<boolean>;
+  constructor();
+  protected readonly jours: Signal<readonly JourDuFil[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMessageThread, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMessageThread, "st-message-thread", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "messages": {
+      "alias": "messages";
+      "required": true;
+      "isSignal": true;
+    };
+    "fige": {
+      "alias": "fige";
+      "required": false;
+      "isSignal": true;
+    };
+    "precedents": {
+      "alias": "precedents";
+      "required": false;
+      "isSignal": true;
+    };
+    "chargementDesPrecedents": {
+      "alias": "chargementDesPrecedents";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "chargerPrecedents": "chargerPrecedents";
+    "reessai": "reessai";
+  }, never, never, true, never>;
+}
+/**
+ * Le composeur d'un fil (lot 266) : un texte brut, des pieces jointes, « Envoyer ».
+ *
+ * ```html
+ * <st-message-composer (envoi)="envoyer($event)" [envoiEnCours]="envoi.enCours()" />
+ * ```
+ *
+ * - TEXTE BRUT : l'editeur riche reste ecarte, aucun HTML n'entre ni ne sort (SEC-6).
+ * - « Envoyer » est indisponible a vide ; Ctrl+Entree (Cmd+Entree) envoie aussi, depuis le champ.
+ * - Le brouillon n'est JAMAIS stocke dans le navigateur (ni `localStorage`, ni `sessionStorage` :
+ *   garde de lint) ; il vit le temps de l'ecran.
+ * - L'envoi remet le texte et les fichiers a l'application, puis vide le composeur : le message
+ *   entre dans le fil, et c'est la qu'un echec se reprend. La cle d'idempotence est posee par
+ *   l'application (son intercepteur), jamais ici.
+ * - Catalogue retombe sur le francais : `lang="fr"` sur « Envoyer » (audit du 2026-09-27, D-29).
+ *   L'etiquette et l'aide du champ, ecrites par `st-textarea` avec la zone de saisie, gardent la
+ *   langue de la page : un `lang` sur la zone ferait passer son correcteur au francais.
+ */
+export declare class StMessageComposer {
+  private readonly catalogue;
+  protected readonly libelles: Signal<LibellesMessagerie>;
+  /** `fr` quand le catalogue retombe sur le francais, `null` sinon (D-29). */
+  protected readonly langueDeRepli: Signal<string | null>;
+  /** Le nom du champ ; defaut : « Votre message ». */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  /** Les pieces jointes permises (`accept`) ; vide : aucune. */
+  readonly piecesJointes: import("@angular/core").InputSignal<string>;
+  readonly tailleMax: import("@angular/core").InputSignal<number | null>;
+  /** Un envoi precedent est en cours : « Envoyer » attend. */
+  readonly envoiEnCours: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly envoi: import("@angular/core").OutputEmitterRef<EnvoiDeMessage>;
+  protected readonly texte: import("@angular/core").WritableSignal<string>;
+  protected readonly fichiers: import("@angular/core").WritableSignal<readonly File[]>;
+  protected readonly nom: Signal<string>;
+  protected readonly vide: Signal<boolean>;
+  protected envoyer(evenement?: Event): void;
+  protected auClavier(evenement: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StMessageComposer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StMessageComposer, "st-message-composer", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "piecesJointes": {
+      "alias": "piecesJointes";
+      "required": false;
+      "isSignal": true;
+    };
+    "tailleMax": {
+      "alias": "tailleMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "envoiEnCours": {
+      "alias": "envoiEnCours";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "envoi": "envoi";
+  }, never, never, true, never>;
+}
+
+export {};

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

@@ -0,0 +1,242 @@
+import * as i0 from "@angular/core";
+/**
+ * `rail` (lot 176) : RESERVE au rail de 72 px de la planche 6 (D22 : tiroir sous `md`, rail de `md` a
+ * `xl`, colonne au-dela), que le lot 235 dessine. Le type est fixe des la 0.9 pour que ce lot ne
+ * change pas une sortie publique (`modeEffectif`) ; d'ici la, le rail se rend en colonne.
+ */
+export type ModeDeNavigation = 'auto' | 'persistant' | 'modal' | 'rail';
+/**
+ * Navigation laterale : une region a cote du contenu sur grand ecran, un tiroir
+ * sur petit ecran.
+ *
+ * ```html
+ * <st-app-shell>
+ *   <button entete stButton [stSidenavToggle]="navigation">Menu</button>
+ *   <st-sidenav navigation #navigation etiquette="Navigation principale">
+ *     <a routerLink="/comptes">Comptes</a>
+ *   </st-sidenav>
+ *   …
+ * </st-app-shell>
+ * ```
+ *
+ * ⚠️ **Deux modes, jamais confondus.** Persistante, c'est une REGION de la page :
+ * aucun piege, rien a ouvrir. Modale, c'est un TIROIR, donc un `StDialog` — role,
+ * piegeage du focus, Echap, retour du focus au bouton — et non une region
+ * glissee par-dessus la page avec un peu de CSS, qui laisserait le clavier
+ * parcourir la page cachee dessous.
+ *
+ * ⚠️ **Elle porte son propre `<nav>`, et un seul a la fois.** Sur petit ecran,
+ * la region en ligne DISPARAIT quand le tiroir prend le relais : laissee en
+ * place, elle resterait un repere de navigation vide, que le lecteur d'ecran
+ * proposerait sans rien y trouver.
+ *
+ * Un lien suivi dans le tiroir le ferme : `StDialog` se ferme a toute navigation
+ * du routeur.
+ */
+export declare class StSidenav {
+  private readonly injecteur;
+  private readonly libelles;
+  /**
+   * Nom du repere. `null` : « Navigation principale », du dictionnaire. A
+   * renseigner des qu'une page compte deux navigations, qui doivent se
+   * distinguer.
+   */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  protected readonly etiquetteLue: import("@angular/core").Signal<string>;
+  /** `auto` : persistante sur grand ecran, tiroir en dessous. */
+  readonly mode: import("@angular/core").InputSignal<ModeDeNavigation>;
+  protected readonly identifiant: string;
+  private readonly ecranLarge;
+  /** Mode reellement applique. Lu par le bouton, qui ne s'affiche qu'en tiroir. */
+  readonly modeEffectif: import("@angular/core").Signal<"persistant" | "modal" | "rail">;
+  private readonly ouvertInterne;
+  readonly ouvert: import("@angular/core").Signal<boolean>;
+  private readonly chargementDuTiroir;
+  /**
+   * Le module du tiroir se charge encore, passe `rythme.delai.attente` (03 §3.9,
+   * MV-12). Lu par le bouton de bascule, qui pose `aria-busy` : sans lui,
+   * l'ouverture differee etait INVISIBLE, et un second clic semblait necessaire.
+   * Pas d'indicateur dans un bouton-icone de 44 px : le curseur d'attente suffit.
+   */
+  readonly enAttente: import("@angular/core").Signal<boolean>;
+  private readonly gabarit;
+  private reference;
+  private ouvertureEnCours;
+  private detruit;
+  /**
+   * Le service de dialogue, charge a la PREMIERE ouverture et garde ensuite.
+   * Rend `null` si le composant a ete detruit pendant l'attente.
+   *
+   * ⚠️ Le specificateur etant dans la carte d'importation de l'application
+   * federee, cet import dynamique resout vers l'INSTANCE PARTAGEE du point
+   * d'entree : le tiroir emploie le meme `StDialog`, le meme recouvrement et la
+   * meme pile que le reste de l'application. Un import dynamique ne dedouble
+   * rien ; il decale seulement le moment du telechargement.
+   *
+   * ⚠️ **Le controle de destruction est ICI, avant `injecteur.get`, et non chez
+   * l'appelant.** Un injecteur detruit ne rend pas `undefined` : il LEVE
+   * (NG0205). Le controle place apres la resolution du service arrivait donc
+   * trop tard, et une navigation pendant le chargement du module produisait un
+   * rejet non gere — invisible en developpement, remonte comme erreur
+   * applicative en production, puisque `basculer()` appelle `ouvrir()` sans
+   * attendre sa promesse.
+   */
+  private serviceDeDialogue;
+  constructor();
+  /**
+   * Ouvre le tiroir. Asynchrone depuis la 0.8.0 : le module du dialogue se
+   * charge a la demande. La promesse est tenue quand le tiroir est a l'ecran —
+   * un test l'attend, l'appelant ordinaire n'a rien a en faire.
+   */
+  ouvrir(): Promise<void>;
+  fermer(): void;
+  /** Reste synchrone : c'est ce que lit la liaison de clic du bouton. */
+  basculer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSidenav, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSidenav, "st-sidenav", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Bouton qui ouvre la navigation en tiroir.
+ *
+ * ⚠️ **Masque quand la navigation est persistante.** Un bouton « Menu » qui ne
+ * fait rien, parce que la navigation est deja affichee a cote, est un arret de
+ * tabulation inutile et une promesse non tenue.
+ *
+ * ⚠️ `aria-expanded` suit l'ouverture du tiroir : sans lui, rien ne dit a qui
+ * n'en voit pas l'effet que le bouton a agi.
+ *
+ * `aria-busy` pendant le chargement DIFFERE du tiroir, passe le delai d'attente
+ * (MV-12) : le clic a ete pris, la navigation arrive.
+ */
+export declare class StSidenavToggle {
+  readonly stSidenavToggle: import("@angular/core").InputSignal<StSidenav>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSidenavToggle, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StSidenavToggle, "[stSidenavToggle]", never, {
+    "stSidenavToggle": {
+      "alias": "stSidenavToggle";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Un onglet de navigation : une ROUTE, son libelle deja traduit, un compte optionnel. */
+export interface OngletDeNavigation {
+  readonly libelle: string;
+  readonly lien: string | readonly unknown[];
+  /** Actif sur la route exacte seulement (un onglet « Vue d'ensemble » a la racine du dossier). */
+  readonly exact?: boolean;
+  /** Un compte : visible en pastille, lu dans le nom (« Documents, 3 »), comme `st-tabs`. */
+  readonly compte?: number | null;
+}
+/**
+ * La navigation secondaire d'une page par ROUTES (lot 245) : les sections d'un dossier client
+ * (« Vue d'ensemble », « Documents », « Historique »), chacune a son adresse.
+ *
+ * ```html
+ * <st-page-header titre="Dossier 2026-0412">
+ *   <st-nav-tabs etiquette="Sections du dossier" [onglets]="sections" />
+ * </st-page-header>
+ * ```
+ *
+ * - Une `nav` NOMMEE, une liste, des liens : jamais `role="tablist"` (des onglets sans panneaux
+ *   mentent). Un commutateur de vue sur place est un `st-segmented-control` ; des panneaux sur
+ *   place, `st-tabs`.
+ * - Le lien courant porte `aria-current="page"` (le routeur) : graisse, aplat et marqueur de
+ *   `st-tabs`, jamais la couleur seule ; sous contraste force, le marqueur reste.
+ * - Un compte se voit en pastille et se lit dans le nom (« Documents, 3 »), formate a la locale.
+ * - La liste defile horizontalement quand elle deborde, ombres aux bords ; aucun libelle tronque.
+ *
+ * Dans `ui/navigation` et non au tronc : la coquille ne la peint pas (D144).
+ */
+export declare class StNavTabs {
+  private readonly locale;
+  private readonly formatDesComptes;
+  readonly onglets: import("@angular/core").InputSignal<readonly OngletDeNavigation[]>;
+  /** Le nom de la navigation (« Sections du dossier »), deja traduit : distinct de la principale. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  protected compteDe(compte: number): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StNavTabs, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StNavTabs, "st-nav-tabs", never, {
+    "onglets": {
+      "alias": "onglets";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Une entree du sommaire : l'`id` de la section cible, et son libelle deja traduit. */
+export interface EntreeDeSommaire {
+  readonly cible: string;
+  readonly libelle: string;
+}
+/**
+ * Le sommaire d'une longue page (lot 245) : des ancres vers ses sections (conditions generales,
+ * aide, mentions). Une `nav` nommee « Sommaire », une liste ordonnee de liens `#id`.
+ *
+ * ```html
+ * <st-page-nav [entrees]="[{ cible: 'frais', libelle: 'Frais' }, { cible: 'resiliation', libelle: 'Resiliation' }]" />
+ * ```
+ *
+ * - Un clic fait defiler jusqu'a la section et Y PORTE LE FOCUS (le titre de la section, rendu
+ *   focalisable par script) : la personne au clavier continue la ou elle lit. Aucune navigation du
+ *   routeur ; l'adresse garde l'ancre (`history.replaceState`), pour un lien partage.
+ * - La section courante (la premiere visible) porte `aria-current="location"`, vue par un
+ *   `IntersectionObserver` ; graisse et trait de debut de ligne, jamais la couleur seule.
+ * - Un titre visible (« Sommaire », ou `etiquette`) nomme la navigation.
+ * - Collee a partir de `lg` (`collee`), a cote du contenu.
+ */
+export declare class StPageNav {
+  private readonly document;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  readonly entrees: import("@angular/core").InputSignal<readonly EntreeDeSommaire[]>;
+  /** Le nom de la navigation ; defaut : « Sommaire ». */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  readonly collee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly nom: import("@angular/core").Signal<string>;
+  protected readonly idDuTitre: string;
+  /** L'`id` de la section courante : la premiere que l'ecran montre. */
+  protected readonly courante: import("@angular/core").WritableSignal<string | null>;
+  constructor();
+  /**
+   * Aller a la section : defiler, porter le focus a son TITRE (une section entiere focalisee se
+   * lirait d'un bloc ; la cible elle-meme quand elle est un titre ou n'en contient pas), garder
+   * l'ancre dans l'adresse.
+   */
+  protected aller(evenement: MouseEvent, cible: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPageNav, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StPageNav, "st-page-nav", never, {
+    "entrees": {
+      "alias": "entrees";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "collee": {
+      "alias": "collee";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+
+export {};