@starterlib/ui 0.9.0 → 0.10.0

package/types/starterlib-ui-mise-en-page.d.ts

@@ -0,0 +1,355 @@
+import * as i0 from "@angular/core";
+import { Icone, TonDIcone } from "@starterlib/ui";
+export type EspacementDeSection = 'aucun' | 'sm' | 'md' | 'lg';
+/**
+ * Regroupement de contenu, expose comme REPERE de navigation quand il porte un
+ * nom, pose en ATTRIBUT sur une vraie balise `section`.
+ *
+ * ```html
+ * <section stSection titreDe="titre-operations" surtitre="Compte courant">
+ *   <h2 stHeading titre id="titre-operations">Operations recentes</h2>
+ *   <button stButton fin type="button">Exporter</button>
+ *   …
+ * </section>
+ * ```
+ *
+ * ⚠️ Le point qui decide de tout : une region n'est exposee comme repere que si
+ * elle a un NOM ACCESSIBLE. Sans nom, la plupart des lecteurs d'ecran
+ * l'ignorent — la balise est la, le repere n'existe pas, et rien ne le signale.
+ * Une `section` native sans nom reste un simple bloc, ce qu'elle est
+ * reellement : son role de region vient de son nom, sans rien poser.
+ *
+ * Deux facons de la nommer, et la seconde vaut mieux : `titreDe` pointe le
+ * titre deja affiche, ce qui garde un seul texte a traduire et a maintenir. On
+ * nomme une section quand une personne au lecteur d'ecran voudrait y SAUTER ;
+ * au-dela de cinq reperes nommes par page, on regroupe.
+ *
+ * L'en-tete (planches 11 a 14) est facultatif : surtitre, titre projete
+ * (`[titre]`), description, et ce qui se place au bout (`[fin]` : une puce, une
+ * action). Sans aucun des quatre, il n'existe pas.
+ */
+export declare class StSection {
+  /** Nom accessible ecrit a la main. A preferer `titreDe` quand un titre existe. */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  /** Identifiant du titre qui nomme la section. Prime sur `etiquette`. */
+  readonly titreDe: import("@angular/core").InputSignal<string | null>;
+  /** Marge apres la section : 0, 16, 24 (defaut) ou 32 px. */
+  readonly espacement: import("@angular/core").InputSignal<EspacementDeSection>;
+  /** Petites capitales au-dessus du titre (planche 11). */
+  readonly surtitre: import("@angular/core").InputSignal<string | null>;
+  /** Une phrase sous le titre (planches 13 et 14). */
+  readonly description: import("@angular/core").InputSignal<string | null>;
+  private readonly element;
+  /**
+   * ⚠️ `aria-labelledby` et `aria-label` sont PARTAGES avec l'appelant
+   * (`noyau/attributs-partages`) : le composant ne pose que ce que ses entrees disent, et garde
+   * ce que l'appelant a ecrit OU LIE (`[attr.aria-labelledby]="idTitre"`). Une liaison d'hote
+   * effacait le nom lie, et la section cessait d'etre un repere sans rien dire (revue E7).
+   */
+  private readonly nommeePar;
+  private readonly nom;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSection, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSection, "section[stSection]", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "titreDe": {
+      "alias": "titreDe";
+      "required": false;
+      "isSignal": true;
+    };
+    "espacement": {
+      "alias": "espacement";
+      "required": false;
+      "isSignal": true;
+    };
+    "surtitre": {
+      "alias": "surtitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[titre]", "[fin]", "*"], true, never>;
+}
+export type OrientationDeSeparateur = 'horizontale' | 'verticale';
+/**
+ * `filet` (defaut) : la bordure decorative #d7dadf ; `tonale` : le trait de la surface du
+ * conteneur haut #e3e8f4, pose dans un panneau teinte (planches 10, 11 et 13). Un separateur
+ * porteur de sens prend la bordure forte (3,78:1) quelle que soit la variante.
+ */
+export type VarianteDeSeparateur = 'filet' | 'tonale';
+/**
+ * Trait de separation.
+ *
+ * ⚠️ **Decoratif par defaut, et c'est le bon defaut.** Un `<hr>` porte le role
+ * `separator` de facon implicite, que les lecteurs d'ecran annoncent. Sur une
+ * page qui en compte huit — ce qui est courant dans une liste de reglages — la
+ * lecture est ponctuee de huit « separateur » qui n'apprennent rien.
+ *
+ * Le role ne se pose que lorsque le trait porte vraiment du sens : il separe
+ * alors deux GROUPES que rien d'autre ne distingue, comme les sections d'un
+ * menu. Regle de tri : si le retirer ne retire aucune information, il est
+ * decoratif. Decoratif, il porte `aria-hidden` SEUL : un `role="none"` en plus
+ * ne disait rien de plus a un element deja retire de l'arbre.
+ *
+ * Porteur de sens, il prend la bordure FORTE (3:1, WCAG 1.4.11) : un trait qui
+ * separe deux groupes doit se voir. Marges : `--st-separateur-marge` (catalogue).
+ *
+ * Avec texte (lot 214) : un mot ou une date courte projetes (« ou », « Aujourd'hui ») se centrent
+ * entre deux traits, en style `legende` a l'encre attenuee. Le TEXTE est lu a sa place dans le
+ * flux ; les traits, dessines par la feuille, ne le sont pas. Ni `separator` (ses enfants sont
+ * presentationnels : le mot serait tu), ni `aria-hidden` (il le retirerait). Horizontal seulement.
+ *
+ * ```html
+ * <st-divider>ou</st-divider>
+ * ```
+ */
+export declare class StDivider {
+  readonly orientation: import("@angular/core").InputSignal<OrientationDeSeparateur>;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeSeparateur>;
+  /** Le trait separe deux groupes distincts, et doit donc etre annonce. */
+  readonly porteurDeSens: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Un texte est-il projete ? Releve au rendu : un contenu projete echappe aux requetes. */
+  protected readonly avecTexte: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDivider, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDivider, "st-divider", never, {
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "porteurDeSens": {
+      "alias": "porteurDeSens";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export type VarianteDeTexte = 'corps' | 'corps-sm' | 'discret' | 'legende' | 'meta' | 'mono';
+export type GraisseDeTexte = 'normale' | 'moyenne' | 'semi';
+/**
+ * Bloc de texte de l'echelle typographique.
+ *
+ * L'hote EST la boite : jamais `display: contents`, qui retire l'element de
+ * l'arbre d'accessibilite dans plusieurs navigateurs. Seul un texte `revelable`
+ * gagne une zone interieure, parce que son bouton doit rester HORS de la coupe.
+ *
+ * ```html
+ * <st-text variante="meta">Mis a jour il y a 2 min</st-text>
+ * <st-text [tronquerA]="3" revelable>{{ conditions }}</st-text>
+ * ```
+ */
+export declare class StText {
+  readonly variante: import("@angular/core").InputSignal<VarianteDeTexte>;
+  readonly graisse: import("@angular/core").InputSignal<GraisseDeTexte>;
+  readonly enLigne: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Nombre de lignes au-dela duquel le texte est coupe.
+   *
+   * ⚠️ A ne jamais employer sur un message d'erreur, un statut, un libelle
+   * d'action, un montant ou un nom qui distingue : une information tronquee y
+   * devient fausse. Le texte coupe reste lu en entier par un lecteur d'ecran ;
+   * l'oeil, lui, n'en voit que le debut, d'ou `revelable`.
+   *
+   * ⚠️ **Sans `revelable`, un APERCU seulement** : le texte entier doit s'atteindre
+   * ailleurs, a l'oeil et au clavier (la ligne est un lien vers le detail, ou le
+   * detail est sur la page). Une bulle `title` ne le remplace pas : ni le clavier ni
+   * le toucher ne l'ouvrent (WCAG 1.4.10 et 2.1.1 ; audit UI du 2026-09-27, D-34).
+   * Partout ailleurs, `revelable`.
+   */
+  readonly tronquerA: import("@angular/core").InputSignal<number | null>;
+  /**
+   * Avec `tronquerA` : un bouton « Afficher la suite » / « Reduire » sous le
+   * bloc, SEULEMENT quand le texte deborde reellement de sa coupe (WCAG 1.4.4 et
+   * 1.4.10 : ce que la coupe cache doit rester atteignable a l'oeil).
+   */
+  readonly revelable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  protected readonly identifiantDuContenu: string;
+  protected readonly ouvert: import("@angular/core").WritableSignal<boolean>;
+  protected readonly deborde: import("@angular/core").WritableSignal<boolean>;
+  private readonly zone;
+  constructor();
+  protected basculer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StText, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StText, "st-text", never, {
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "graisse": {
+      "alias": "graisse";
+      "required": false;
+      "isSignal": true;
+    };
+    "enLigne": {
+      "alias": "enLigne";
+      "required": false;
+      "isSignal": true;
+    };
+    "tronquerA": {
+      "alias": "tronquerA";
+      "required": false;
+      "isSignal": true;
+    };
+    "revelable": {
+      "alias": "revelable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * `ligne` : filet capillaire entre les lignes d'une liste de reglages (le
+ * defaut) ; `tuile` : chaque reglage dans sa tuile `surfaceConteneurBas`
+ * (regles de la planche 14).
+ */
+export type VarianteDeLigneDeReglage = 'ligne' | 'tuile';
+/**
+ * Ligne de reglage : un libelle, une description, et le controle qui les suit.
+ *
+ * ```html
+ * <st-settings-row libelle="Alertes par SMS" description="Un SMS a chaque virement sortant.">
+ *   <st-switch libelle="Activer" [(checked)]="sms" />
+ * </st-settings-row>
+ * ```
+ *
+ * Facultatifs : un carre d'icone de 36 px en tete (`icone`, `ton`), et un
+ * complement du libelle sur sa ligne (`[suffixe]`, une puce « STRICT »).
+ *
+ * ⚠️ **La ligne est un GROUPE nomme et decrit, et non une etiquette.** Le
+ * controle projete garde son propre nom — celui de son `libelle`, ou un
+ * `aria-label` pour un element natif — et la ligne l'enveloppe d'un
+ * `role="group"` relie a son libelle par `aria-labelledby` et a sa description
+ * par `aria-describedby`. En entrant dans le groupe, le lecteur d'ecran lit le
+ * libelle, puis la description, puis le controle : « Alertes par SMS, groupe,
+ * Un SMS a chaque virement sortant, Activer, interrupteur, desactive ». En
+ * developpement, un controle projete SANS nom accessible est signale.
+ *
+ * Pourquoi pas un `label for` : la plupart des controles du socle portent deja
+ * leur etiquette, et un controle non natif (un groupe segmente, un declencheur
+ * de menu) n'en accepte aucun. Le groupe, lui, marche pour tous, sans que la
+ * ligne ait a connaitre ce qu'on lui projette.
+ *
+ * ⚠️ Un reglage s'applique IMMEDIATEMENT (c'est le sens de `st-switch`) ou
+ * s'envoie avec un formulaire : la ligne ne tranche pas, le controle le dit.
+ *
+ * Une ligne qui NAVIGUE (vers le detail d'un reglage) projette un `a[stLink]`
+ * suivi de l'icone `chevron-droite` de taille `sm`, miroitee en RTL.
+ */
+export declare class StSettingsRow {
+  /** Texte visible, deja traduit : le socle ne traduit rien. */
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  /** Ce que le reglage fait, en une phrase. Reliee au groupe par `aria-describedby`. */
+  readonly description: import("@angular/core").InputSignal<string | null>;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeLigneDeReglage>;
+  /** Icone decorative du carre de tete ; `null` : pas de carre. */
+  readonly icone: import("@angular/core").InputSignal<Icone | null>;
+  /** Ton du glyphe du carre d'icone. */
+  readonly ton: import("@angular/core").InputSignal<TonDIcone>;
+  /** Identifiants du libelle et de la description, cibles des attributs ARIA. */
+  protected readonly identifiants: {
+    readonly libelle: `${string}-libelle`;
+    readonly description: `${string}-description`;
+  };
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSettingsRow, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSettingsRow, "st-settings-row", never, {
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "icone": {
+      "alias": "icone";
+      "required": false;
+      "isSignal": true;
+    };
+    "ton": {
+      "alias": "ton";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[suffixe]", "*"], true, never>;
+}
+/**
+ * Regroupe des actions liees.
+ *
+ * ⚠️ `role="group"` et NON `role="toolbar"` : une barre d'outils exige un
+ * `tabindex` glissant et la navigation par fleches. Annoncer « barre d'outils »
+ * sans en fournir le comportement desoriente plus qu'un groupe simple. Le
+ * motif complet viendra avec les primitives d'`@angular/aria`.
+ *
+ * `attache` : le groupe marque ses enfants du tronc (`stButton`, `stIconButton`,
+ * `stLink`) par leur position, et chaque enfant rend ses coins (`_groupe.scss`) ; un
+ * enfant survole ou focalise passe au-dessus de son voisin. Les enfants d'un groupe
+ * attache ont la MEME taille (avertissement en developpement), et le groupe passe a la
+ * ligne plutot que de deborder (1.4.10). Au-dela de cinq boutons attaches, un
+ * `st-segmented-control` ou un `st-select` dit mieux la chose.
+ *
+ * `plateau` : le groupe pose sur le fond du conteneur, rayon et filet discret (planche 9).
+ */
+export declare class StButtonGroup {
+  /** Nom du groupe : sans lui, le regroupement n'apprend rien a l'oral. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  readonly orientation: import("@angular/core").InputSignal<"horizontale" | "verticale">;
+  /** Boutons jointifs : un seul trait entre deux, coins exterieurs seulement. */
+  readonly attache: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le groupe pose sur un plateau (planche 9). */
+  readonly plateau: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly boutons;
+  private readonly boutonsIcone;
+  private readonly liens;
+  private readonly taillesDesBoutons;
+  private readonly taillesDesBoutonsIcone;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StButtonGroup, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StButtonGroup, "st-button-group", never, {
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "attache": {
+      "alias": "attache";
+      "required": false;
+      "isSignal": true;
+    };
+    "plateau": {
+      "alias": "plateau";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["boutons", "boutonsIcone", "liens", "taillesDesBoutons", "taillesDesBoutonsIcone"], ["*"], true, never>;
+}
+
+export {};

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

@@ -39,6 +39,12 @@ export type OrientationDOnglets = 'horizontale' | 'verticale';
  * </st-tabs>
  * ```
  *
+ * ⚠️ **Un `st-tab-panel` par onglet, son contenu dans `stTabContent`** : depuis Angular 22.2,
+ * `@angular/aria` signale en developpement un onglet sans panneau et un panneau sans contenu
+ * differe (deux avertissements par element). Le contenu direct d'un panneau reste rendu, et
+ * masque au repos, mais il est signale ; des vues d'un meme contenu, sans panneau, se disent par
+ * `st-segmented-control`.
+ *
  * ⚠️ **La liste d'onglets est rendue par le composant, a partir de donnees**, et
  * non projetee. Les primitives d'Aria relient un onglet a sa liste par
  * INJECTION, et un contenu projete garde l'injecteur de l'endroit ou il est

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

@@ -1,8 +1,8 @@
 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";
+import { AnnonceLocale, Icone, NiveauDeTitre } from "@starterlib/ui";
+import { DispositionDActions, 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`).
@@ -312,6 +312,126 @@ export declare class StTaskList {
     "ouverture": "ouverture";
   }, never, never, true, never>;
 }
+/** Une etape d'un parcours, decrite par l'appelant. Les textes sont deja traduits. */
+export interface EtapeDeParcours {
+  readonly libelle: string;
+  /** Precision sous le libelle (« Termine le 28.09 a 14:32 ») ; aucune si absente. */
+  readonly description?: string;
+}
+export type EtatDEtape = 'faite' | 'courante' | 'a-venir';
+/** `verticale` : les etapes en colonne, a toutes les largeurs (un assistant a sa marge, lot 262). */
+export type OrientationDeParcours = 'horizontale' | 'verticale';
+/**
+ * Parcours par etapes : ou l'on en est, ce qui est fait, ce qui reste.
+ *
+ * ```html
+ * <st-stepper [etapes]="etapes" [etape]="indice()" />
+ * ```
+ *
+ * ⚠️ Une liste ORDONNEE : l'ordre des etapes est l'information, et le lecteur
+ * d'ecran annonce « 2 sur 4 » de lui-meme. L'etape courante porte
+ * `aria-current="step"`, ce qui est exactement le mot de la specification, et
+ * elle est seule a le porter.
+ *
+ * ⚠️ **L'etat de chaque etape se lit par sa forme ET par un texte**, jamais par
+ * la couleur seule : une coche pour ce qui est fait, un numero plein a halo pour
+ * l'etape en cours, un numero sur fond discret pour ce qui vient ; et un mot —
+ * « en cours », « a venir » dans le surtitre visible, « terminee » lu seulement,
+ * la double coche le montrant. Sous contraste force, il ne reste que la forme et
+ * le mot.
+ *
+ * Deux formes, sans transition de l'une a l'autre : la RANGEE (reperes de 40 px
+ * relies par des connecteurs de 4 px, surtitre, libelle, description) des que
+ * SA BOITE atteint la rupture `md` (requete de conteneur : une carte etroite sur
+ * un grand ecran prend la forme compacte), et la forme COMPACTE en dessous (« Etape 3 sur 4 : ... »,
+ * pourcentage CALCULE, un segment par etape, precedente et suivante). La forme
+ * compacte est une vue : la liste complete reste dans le document, lue
+ * seulement, et la vue est masquee aux lecteurs d'ecran pour ne rien dire deux
+ * fois. `compacte` l'impose a toutes les largeurs.
+ *
+ * Il n'est PAS interactif : revenir a une etape est une decision du parcours,
+ * qui la rend par un vrai lien ou un vrai bouton dans la page. Un indicateur
+ * cliquable promettrait un retour que tous les parcours n'autorisent pas.
+ *
+ * Le composant ne pose aucune marge externe : l'espace autour de lui appartient
+ * a la page.
+ */
+export declare class StStepper {
+  private readonly libelles;
+  private readonly locale;
+  readonly etapes: import("@angular/core").InputSignal<readonly EtapeDeParcours[]>;
+  /**
+   * Indice de l'etape en cours, a partir de zero. Le nombre d'etapes dit un
+   * parcours acheve : toutes faites, aucune courante. Hors de ces bornes,
+   * l'indice est ramene a la plus proche, avec un avertissement en developpement.
+   */
+  readonly etape: import("@angular/core").InputSignal<number>;
+  /**
+   * Nom de la liste, jamais affiche. `null` : le `libelle` visible s'il est pose (un voyant lit
+   * « Virement », un lecteur d'ecran l'entend aussi), sinon « Etapes », du dictionnaire.
+   */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  /** Nom visible du parcours, en surtitre de la forme compacte ; aucun si `null`. */
+  readonly libelle: import("@angular/core").InputSignal<string | null>;
+  /** Forme compacte a toutes les largeurs, et non sous la seule rupture `md`. */
+  readonly compacte: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `verticale` : la liste en colonne a toutes les largeurs ; `compacte` l'emporte. */
+  readonly orientation: import("@angular/core").InputSignal<OrientationDeParcours>;
+  protected readonly etiquetteLue: import("@angular/core").Signal<string>;
+  protected readonly motDeLEtapeFaite: import("@angular/core").Signal<string>;
+  /** L'indice borne : une etape hors du parcours ne peut ni tout cocher ni tout vider en silence. */
+  private readonly courante;
+  protected readonly lignes: import("@angular/core").Signal<{
+    libelle: string;
+    description: string | null;
+    numero: number;
+    etat: EtatDEtape;
+    surtitre: string;
+    relie: boolean;
+  }[]>;
+  /** Le format de la locale de l'application : « 50 % » en francais, « 50% » en anglais. */
+  private readonly formatDuPourcentage;
+  /** Resume de la forme compacte : CALCULE sur les etapes faites, jamais recopie. */
+  protected readonly resume: import("@angular/core").Signal<{
+    titre: string;
+    pourcentage: string;
+    precedente: string | null;
+    suivante: string | null;
+  } | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StStepper, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StStepper, "st-stepper", never, {
+    "etapes": {
+      "alias": "etapes";
+      "required": true;
+      "isSignal": true;
+    };
+    "etape": {
+      "alias": "etape";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelle": {
+      "alias": "libelle";
+      "required": false;
+      "isSignal": true;
+    };
+    "compacte": {
+      "alias": "compacte";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, 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. */
@@ -442,7 +562,7 @@ export declare class StWizardStep {
   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 orientation: import("@angular/core").Signal<import("@starterlib/ui/parcours").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). */

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

@@ -1,8 +1,10 @@
-import { Adresse, DateIso, DescriptionDeFichier, FormatDAdresse, HeureIso, NatureDeRegion, PartieDAdresse, PlageDeDates, sansCommandesDeDirection } from "@starterlib/util";
+import { Adresse, DateIso, DescriptionDeFichier, FormatDAdresse, HeureIso, NatureDeRegion, PartieDAdresse, PlageDeDates } from "@starterlib/util/valeurs";
 import { DisabledReason, FormCheckboxControl, FormValueControl, ValidationError, WithOptionalFieldTree } from "@angular/forms/signals";
-import { AnnonceLocale, EtiquetteDeGroupe, Icone, LibellesUi } from "@starterlib/ui";
+import { AnnonceLocale, Icone, LibellesUi } from "@starterlib/ui";
 import * as i0 from "@angular/core";
 import { InjectionToken, Signal } from "@angular/core";
+import { sansCommandesDeDirection } from "@starterlib/util";
+import { EtiquetteDeGroupe } from "@starterlib/ui/indicateurs";
 /**
  * Forme minimale d'une erreur de validation, telle que Signal Forms la rend :
  * un genre, et parfois un message.
@@ -3802,5 +3804,73 @@ export declare class StAddressFieldset extends ContratDeChamp implements FormVal
     "value": "valueChange";
   }, never, ["*"], true, never>;
 }
+/**
+ * `collee` (defaut, planche 3b) : une carte collee au bas de la zone de
+ * defilement, a 16 px du bord. `pied` (planche 13) : une rangee posee a la fin du
+ * formulaire, sans cadre, pour un formulaire qui tient dans l'ecran.
+ */
+export type DispositionDActions = 'collee' | 'pied';
+/**
+ * Barre d'actions d'un formulaire.
+ *
+ * ```html
+ * <form (submit)="envoyer()">
+ *   …
+ *   <st-form-actions>
+ *     <button debut stButton type="button">Annuler</button>
+ *     <st-icon aide nom="cercle-alerte-plein" ton="danger" />
+ *     <span aide id="aide-envoi">3 erreurs a corriger</span>
+ *     <button stButton type="button">Enregistrer le brouillon</button>
+ *     <button stButton type="submit" variante="primaire" aria-describedby="aide-envoi">
+ *       Valider le virement
+ *     </button>
+ *   </st-form-actions>
+ * </form>
+ * ```
+ *
+ * ⚠️ **`sticky`, JAMAIS `fixed`.** Un element fixe sort du flux : a 200 %
+ * d'echelle il recouvre les derniers champs, et dans une vue embarquee il se
+ * pose sous la barre du systeme. Collee, la barre reste dans le document —
+ * elle suit le formulaire, cede la place a son pied, et respecte la zone sure
+ * du bas de l'ecran (`env(safe-area-inset-bottom)`).
+ *
+ * ⚠️ **Le focus n'est jamais recouvert** (WCAG 2.4.11). Collee, la barre cache
+ * les derniers champs quand le navigateur y amene un arret de tabulation : elle
+ * MESURE sa hauteur et la pose en `scroll-padding-block-end` sur son conteneur
+ * de defilement, avec le contrat d'hote `--st-form-actions-hauteur` (D13, D16).
+ *
+ * ⚠️ **L'ordre du document est l'ordre visuel.** Rien n'est inverse par le
+ * style : l'action principale s'ecrit en dernier, elle se lit en dernier et se
+ * tabule en dernier. `debut` accueille ce qui part a l'oppose (un retour, une
+ * annulation) et `aide` la raison d'une action indisponible, a relier au bouton
+ * par `aria-describedby`. Dans un conteneur de moins de 480 px, la barre
+ * s'empile, l'action principale en bas, sous le pouce (planche 6).
+ *
+ * `data-collee` dit que la barre FLOTTE sur du contenu qui continue dessous :
+ * son ombre s'epaissit alors (une barre posee a la fin du formulaire garde
+ * l'ombre de la planche 3b).
+ *
+ * Une seule action principale par formulaire, et elle est un vrai
+ * `type="submit"` : Entree dans un champ l'envoie. Deux avertissent en
+ * developpement.
+ */
+export declare class StFormActions {
+  readonly disposition: import("@angular/core").InputSignal<DispositionDActions>;
+  protected readonly collee: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  /**
+   * Observe la barre collee : si elle flotte (`data-collee`) et quelle hauteur
+   * elle recouvre. Rend la fonction qui defait tout.
+   */
+  private suivreLaBarre;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StFormActions, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StFormActions, "st-form-actions", never, {
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[debut]", "[aide]", "*"], true, never>;
+}
 
 export {};

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

@@ -1,9 +1,10 @@
 import { AnnonceLocale } from "@starterlib/ui";
 import { ContratDeChamp, ControleDeSaisie, OptionDeListe, PresentationDeLibelle } from "@starterlib/ui/saisie";
-import { SuggestionDAdresse, sansCommandesDeDirection } from "@starterlib/util";
+import { sansCommandesDeDirection } from "@starterlib/util";
 import * as i0 from "@angular/core";
 import { TemplateRef } from "@angular/core";
 import { FormValueControl } from "@angular/forms/signals";
+import { SuggestionDAdresse } from "@starterlib/util/valeurs";
 /** Contexte du gabarit d'option de `st-combobox`. */
 export interface ContexteDOption {
   /** L'option rendue. */
@@ -407,7 +408,7 @@ export declare class StAddressSearch {
   protected readonly minimum = 3;
   /** Rendue seulement avec une source ET dans un champ d'adresse. */
   protected readonly active: boolean;
-  protected readonly attribution: import("@starterlib/util").AttributionDeDonnees | null;
+  protected readonly attribution: import("@starterlib/util/valeurs").AttributionDeDonnees | null;
   /** Le texte tape, temporise par `st-combobox`. */
   protected readonly terme: import("@angular/core").WritableSignal<string>;
   /** La suggestion choisie (son identifiant), ou `''`. */