@starterlib/ui 0.7.2 → 0.9.0

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

@@ -1,15 +1,110 @@
-import * as _starterlib_ui from '@starterlib/ui';
-import { ContratDeChamp, ErreurAffichable } from '@starterlib/ui';
-import * as _angular_forms_signals from '@angular/forms/signals';
-import { FormValueControl } from '@angular/forms/signals';
-import * as _angular_core from '@angular/core';
-import { DateIso, PlageDeDates } from '@starterlib/util';
-
+import { FieldTree, FormValueControl, TreeValidationResult } from "@angular/forms/signals";
+import { AnneesDuCalendrier, ContratDeChamp, ContratDeChampABornes, ControleDeSaisie, ErreurAffichable, EtatDEnvoi, OptionDeListe, OptionRadio } from "@starterlib/ui/saisie";
+import * as i0 from "@angular/core";
+import { InjectionToken, Provider, Signal } from "@angular/core";
+import { AnnonceLocale, CatalogueDuPointDEntree, LibellesUi } from "@starterlib/ui";
+import { DateIso, FrequenceDeRecurrence, HeureIso, PlageDeDates, Recurrence } from "@starterlib/util";
+/**
+ * L'envoi d'un formulaire valide. Il rend les refus du serveur, que Signal Forms place sous leur
+ * champ (`fieldTree`) et au recapitulatif, puis efface des que la valeur du champ change ; rien
+ * (`undefined`) pour un envoi reussi.
+ */
+export type EnvoiDeFormulaire<TModele> = (formulaire: FieldTree<TModele>) => Promise<TreeValidationResult>;
+/**
+ * Un formulaire du socle : la plomberie de l'envoi, ecrite une fois (lot 247).
+ *
+ * ```html
+ * <form [stForm]="virement" [envoyerAvec]="envoyer" (envoi)="confirmer($event)" #formulaire="stForm">
+ *   <st-error-summary />
+ *   <st-input libelle="Beneficiaire" [formField]="virement.beneficiaire" />
+ *   <st-button type="submit" [chargement]="formulaire.enCours()">Envoyer</st-button>
+ * </form>
+ * ```
+ *
+ * ```ts
+ * readonly envoyer: EnvoiDeFormulaire<Virement> = async (formulaire) => {
+ *   try {
+ *     await this.api.virer(formulaire().value());
+ *     return undefined;
+ *   } catch (erreur) {
+ *     return versErreursDeFormulaire(versApiError(erreur), formulaire);
+ *   }
+ * };
+ * ```
+ *
+ * - `novalidate` : les bulles natives du navigateur, dans sa langue, ne doublent pas les messages
+ *   du socle.
+ * - L'envoi (`submit()` de Signal Forms) marque chaque champ touche ; valide, il appelle
+ *   `envoyerAvec`. Les refus du serveur s'affichent sous leur champ et au recapitulatif.
+ * - Pendant l'envoi, le formulaire est `aria-busy` et un second envoi est IGNORE (double clic,
+ *   Entree repetee) : une seule operation part.
+ * - Le `st-error-summary` qu'il contient le lit sans rien lier : il apparait a la premiere
+ *   tentative refusee et reprend le focus a CHAQUE nouvelle tentative (UX-5), jamais a une simple
+ *   correction.
+ * - ⚠️ Un envoi reussi remet le formulaire au propre (`reset()` : ni touche, ni modifie, valeurs
+ *   gardees) et `tentative` a zero, PUIS emet `(envoi)` avec la valeur envoyee. Le formulaire vide
+ *   ensuite ne montre ni recapitulatif focalise ni erreur sous ses champs (constat A0922), meme
+ *   quand l'application vide son modele dans `envoyerAvec`.
+ * - L'option `submission` de `form()` n'est pas lue : l'envoi passe par `envoyerAvec`. Ne pas
+ *   poser `[formRoot]` sur le meme formulaire, il enverrait une seconde fois.
+ *
+ * Dans `@starterlib/ui/formulaires` : l'envoi est du CODE d'`@angular/forms`, que
+ * `@starterlib/ui/saisie` n'importe pas (ADR 0003, ADR web 0005 D135).
+ */
+export declare class StForm<TModele> implements EtatDEnvoi {
+  private readonly destruction;
+  /** Le formulaire de Signal Forms. */
+  readonly stForm: import("@angular/core").InputSignal<FieldTree<TModele>>;
+  /** L'envoi, appele seulement quand le formulaire est valide ; `null` : `(envoi)` suffit. */
+  readonly envoyerAvec: import("@angular/core").InputSignal<EnvoiDeFormulaire<TModele> | null>;
+  /** Emis apres un envoi reussi, avec la valeur envoyee. */
+  readonly envoi: import("@angular/core").OutputEmitterRef<TModele>;
+  private readonly tentatives;
+  /**
+   * L'envoi de la directive, de la tentative a son issue. ⚠️ Plus long que `submitting()` de Signal
+   * Forms, qui retombe AVANT que la directive remette le formulaire au propre : une detection de
+   * changements tombee entre les deux voyait un formulaire vide, une tentative comptee, et le
+   * recapitulatif surgissait, focalise, apres un succes.
+   */
+  private readonly envoiEnCours;
+  /** Les tentatives d'envoi depuis le dernier envoi reussi. */
+  readonly tentative: import("@angular/core").Signal<number>;
+  /**
+   * Un envoi court, le sien ou un `submit()` lance ailleurs : le formulaire est `aria-busy`, un
+   * second envoi est ignore.
+   */
+  readonly enCours: import("@angular/core").Signal<boolean>;
+  /**
+   * Les erreurs a recapituler : aucune avant la premiere tentative, ni pendant l'envoi (un modele
+   * vide par `envoyerAvec` ne fait pas surgir le recapitulatif), ni apres un envoi reussi.
+   */
+  readonly recapitulatif: import("@angular/core").Signal<import("@angular/forms/signals").ValidationError.WithFieldTree[]>;
+  protected surEnvoi(evenement: Event): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StForm<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StForm<any>, "form[stForm]", ["stForm"], {
+    "stForm": {
+      "alias": "stForm";
+      "required": true;
+      "isSignal": true;
+    };
+    "envoyerAvec": {
+      "alias": "envoyerAvec";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "envoi": "envoi";
+  }, never, never, true, never>;
+}
+/** Remplissage automatique d'un montant : `transaction-amount` pour un paiement, rien sinon. */
+export type RemplissageDeMontant = 'transaction-amount';
 /**
  * Montant, en UNITES MINEURES : `123456n` pour 1 234,56 EUR.
  *
  * ```html
  * <st-amount-field libelle="Montant du virement" devise="EUR" [formField]="virement.montant" />
+ * <!-- ou, sans formulaire : -->
+ * <st-amount-field #plafond libelle="Plafond" devise="EUR" [(value)]="plafond" />
  * ```
  *
  * ⚠️ **Jamais un nombre a virgule flottante** (SEC-8) : le modele est un `bigint`,
@@ -19,41 +114,339 @@ import { DateIso, PlageDeDates } from '@starterlib/util';
  * ⚠️ **Un texte ambigu est refuse, jamais devine.** « 1.250 » en francais serait
  * mille deux cent cinquante ou un virgule vingt-cinq : le champ dit l'erreur et
  * garde le texte, plutot que d'envoyer un montant mille fois trop grand. Une
- * saisie illisible laisse le MODELE inchange et rend le formulaire invalide, par
- * `transformedValue` : il ne part pas avec l'ancien montant.
+ * saisie illisible remet le MODELE a `null` — en formulaire comme seul (constats A1123,
+ * A1169) : aucun montant perime (« 12,34 » d'une frappe « 12,345 ») ne subsiste chez
+ * l'appelant. Le formulaire est invalide par `transformedValue` ; employe seul, `lectureInvalide`
+ * distingue un champ vide d'un champ illisible.
+ *
+ * ⚠️ **Une devise mal formee ne casse pas le rendu, et ne jette aucune frappe** : `devise` liee a
+ * une donnee en cours de chargement (`compte()?.devise ?? ''`) laisse le champ sans symbole, en
+ * lecture seule et `aria-busy`, jusqu'a ce qu'un code de trois lettres arrive (avertissement en
+ * developpement), au lieu de lever `RangeError` dans un calcul du gabarit (constats A1177, A1193)
+ * — ou d'accepter une frappe qu'il ne saurait pas lire.
+ *
+ * ⚠️ **Une devise qui change garde le montant qu'on voit.** Le modele est en unites mineures de
+ * la devise : reformate dans une autre, « 1 234,50 € » tape devenait « 123 450 ¥ », un montant cent
+ * fois plus grand, sans rien dire. Le texte affiche est RELU dans la nouvelle devise (« 1 234,50 »
+ * refuse en yens : au plus 0 decimale) ; un montant du modele que la devise attendait (devise en
+ * cours de chargement) s'affiche des qu'elle arrive.
+ *
+ * Le code de la devise est un bloc DANS le cadre (planche 3b), place avant ou apres la valeur
+ * selon la locale (`Intl`, « 1 234,56 CHF » en fr-CH, « £1,234.56 » en en-GB) ; il est
+ * masque au lecteur d'ecran, qui lit le NOM de la devise en description. Valeur alignee a la
+ * fin, chiffres tabulaires a zero barre : plusieurs montants s'alignent en colonne.
  *
  * Le groupement « 1 234,56 » s'applique a la sortie du champ, jamais pendant la
- * frappe. `type="text"` et `inputmode="decimal"` : `type="number"` accepte
+ * frappe, et s'annonce. `type="text"` et `inputmode="decimal"` : `type="number"` accepte
  * « 1e5 », change la valeur a la molette, et ignore la virgule selon le navigateur.
  *
- * Les bornes — montant minimal, plafond — sont des regles du schema, en unites
- * mineures ; le serveur les revalide (SEC-5).
- */
-declare class StAmountField extends ContratDeChamp implements FormValueControl<bigint | null> {
-    private readonly libelles;
-    private readonly locale;
-    readonly value: _angular_core.ModelSignal<bigint | null>;
-    /** Code ISO 4217. Fixe l'echelle : 2 decimales en euros, 0 en yens. */
-    readonly devise: _angular_core.InputSignal<string>;
-    /** `transaction-amount` pour un paiement. */
-    readonly autocomplete: _angular_core.InputSignal<string | null>;
-    /**
-     * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe
-     * seul, rien ne le dirait, et une saisie illisible ne s'afficherait jamais.
-     */
-    protected readonly quitte: _angular_core.WritableSignal<boolean>;
-    protected readonly saisie: _angular_forms_signals.TransformedValueSignal<string>;
-    protected readonly erreursAffichees: _angular_core.Signal<readonly _starterlib_ui.ErreurAffichable[]>;
-    /** Symbole affiche a cote du champ ; le nom de la devise, lui, est lu. */
-    protected readonly symbole: _angular_core.Signal<string>;
-    protected readonly deviseLue: _angular_core.Signal<string>;
-    protected surSaisie(evenement: Event): void;
-    protected aLaSortie(): void;
-    private formater;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StAmountField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StAmountField, "st-amount-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "devise": { "alias": "devise"; "required": true; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
-}
-
+ * Les bornes — montant minimal, plafond — sont des regles du schema, en unites mineures
+ * (`{ kind: 'min', min: 1000n }`) ; le message les dit en devise (« 10,00 € »), et le serveur
+ * les revalide (SEC-5).
+ */
+export declare class StAmountField extends ContratDeChamp implements FormValueControl<bigint | null> {
+  private readonly libelles;
+  private readonly locale;
+  protected readonly annonce: AnnonceLocale;
+  protected readonly idDevise: string;
+  readonly value: import("@angular/core").ModelSignal<bigint | null>;
+  /** Code ISO 4217. Fixe l'echelle : 2 decimales en euros, 0 en yens. */
+  readonly devise: import("@angular/core").InputSignal<string>;
+  /** `transaction-amount` pour un paiement ; rien sinon (WCAG 1.3.5). */
+  readonly autocomplete: import("@angular/core").InputSignal<"transaction-amount" | null>;
+  /** Texte lu apres l'aide et tenu a jour par l'application (« Solde disponible : … »). */
+  readonly complement: import("@angular/core").InputSignal<string | null>;
+  /** Toute la largeur de sa colonne, au lieu des 16rem d'un montant de formulaire. */
+  readonly pleineLargeur: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Identifiants d'autres textes qui decrivent le champ (`aria-describedby`) : l'aide du groupe
+   * d'une plage (`st-amount-range`, lot 255), lue depuis chaque champ et non du seul groupe.
+   */
+  readonly decritPar: import("@angular/core").InputSignal<readonly string[]>;
+  /**
+   * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe
+   * seul, rien ne le dirait, et une saisie illisible ne s'afficherait jamais.
+   */
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  private avertie;
+  /** Le code en majuscules s'il est bien forme, sinon `null` (chargement, faute de frappe). */
+  protected readonly deviseSure: import("@angular/core").Signal<string | null>;
+  protected readonly saisie: import("@angular/forms/signals").TransformedValueSignal<string>;
+  /**
+   * Vrai quand le texte saisi n'est pas un montant : le modele vaut alors `null`, comme un champ
+   * vide. Pour l'appelant sans formulaire, qui doit distinguer les deux.
+   */
+  readonly lectureInvalide: import("@angular/core").Signal<boolean>;
+  /** Erreurs du schema (bornes dites en devise), puis celles de la lecture. */
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly ErreurAffichable[]>;
+  /** Parties de la devise pour la locale : son symbole (« CHF », « € », « £ ») et sa place. */
+  private readonly parties;
+  /** Symbole affiche dans le cadre ; le nom de la devise, lui, est lu. */
+  protected readonly symbole: import("@angular/core").Signal<string>;
+  protected readonly symboleAvant: import("@angular/core").Signal<boolean>;
+  protected readonly deviseLue: import("@angular/core").Signal<string | null>;
+  protected readonly descriptionsDuControle: import("@angular/core").Signal<string[]>;
+  constructor();
+  /** Un clic sur le bloc de devise ou la marge du cadre donne le focus a la zone de frappe. */
+  protected surPressionDuCadre(evenement: MouseEvent): void;
+  protected surSaisie(evenement: Event): void;
+  protected aLaSortie(): void;
+  /** Une borne en unites mineures (`bigint`) se dit en devise : « au moins 10,00 € ». */
+  private borneEnDevise;
+  private formater;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StAmountField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StAmountField, "st-amount-field", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "devise": {
+      "alias": "devise";
+      "required": true;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "complement": {
+      "alias": "complement";
+      "required": false;
+      "isSignal": true;
+    };
+    "pleineLargeur": {
+      "alias": "pleineLargeur";
+      "required": false;
+      "isSignal": true;
+    };
+    "decritPar": {
+      "alias": "decritPar";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
+}
+/**
+ * Les libelles propres a `@starterlib/ui/formulaires` (lot 255) : le catalogue par point d'entree
+ * (AD-10, D147), apres celui de la messagerie. Seuls les NOUVEAUX libelles des champs composes y
+ * vivent ; ceux d'avant restent au dictionnaire du tronc jusqu'a la cloture du train (lot 268). La
+ * langue suit celle du dictionnaire du tronc.
+ */
+export interface LibellesFormulaires {
+  readonly montantMinimal: string;
+  readonly montantMaximal: string;
+  readonly frequence: string;
+  readonly frequences: Readonly<Record<FrequenceDeRecurrence, string>>;
+  readonly intervalle: string;
+  /** L'unite de l'intervalle, apres le nombre (« 2 mois »). */
+  readonly unitesDIntervalle: Readonly<Record<FrequenceDeRecurrence, string>>;
+  readonly jourDuMois: string;
+  /** L'option vide du jour du mois : le jour de la premiere echeance, a defaut. */
+  readonly jourDeLaPremiereEcheance: string;
+  /** L'aide du jour du mois, dite AVANT la saisie : la regle des 29, 30 et 31. */
+  readonly regleDeFinDeMois: string;
+  readonly premiereEcheance: string;
+  readonly fin: string;
+  readonly finJamais: string;
+  readonly finALaDate: string;
+  readonly finApresNombre: string;
+  readonly derniereEcheance: string;
+  readonly nombreDEcheances: string;
+  readonly recapitulatif: string;
+}
+export declare const LIBELLES_FORMULAIRES_FR: LibellesFormulaires;
+export declare const LIBELLES_FORMULAIRES_EN: LibellesFormulaires;
+/** Les catalogues de `formulaires` par langue ; une application en ajoute par la fonction ci-dessous. */
+export declare const ST_LIBELLES_FORMULAIRES: InjectionToken<Readonly<Record<string, LibellesFormulaires>>>;
+export declare function fournirLibellesFormulaires(catalogues: Readonly<Record<string, LibellesFormulaires>>): Provider;
+/**
+ * Le catalogue de la langue du dictionnaire du tronc ; le francais a defaut, un repli signale en
+ * developpement (audit du 2026-09-27, D-29). A appeler dans un contexte d'injection.
+ */
+export declare function libellesDesFormulaires(): Signal<LibellesFormulaires>;
+/**
+ * Le catalogue de `formulaires` 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 catalogueDesFormulaires(): Signal<CatalogueDuPointDEntree<LibellesFormulaires>>;
+/** Une plage de montants, en unites mineures de la devise (`bigint`), bornes facultatives. */
+export interface PlageDeMontants {
+  readonly min: bigint | null;
+  readonly max: bigint | null;
+}
+/** Les libelles des deux parties, quand « Montant minimal » ne dit pas la chose. */
+export interface EtiquettesDePlage {
+  readonly min: string;
+  readonly max: string;
+}
+/**
+ * L'erreur de plage, a poser dans le schema :
+ * `validate(chemin.plafond, ({ value }) => erreurPlageDeMontants(value()))`. Elle s'affiche sous
+ * le MAXIMUM, la partie a corriger.
+ */
+export declare function erreurPlageDeMontants(plage: PlageDeMontants): ErreurAffichable | null;
+/**
+ * Une plage de montants (lot 255) : un minimum et un maximum dans une meme devise, pour filtrer
+ * des operations ou borner un plafond.
+ *
+ * ```html
+ * <st-amount-range libelle="Montant de l'operation" devise="EUR" [formField]="filtres.montant" />
+ * ```
+ *
+ * - Un `st-fieldset` nomme par sa question, deux `st-amount-field` (« Montant minimal »,
+ *   « Montant maximal ») dans la devise commune.
+ * - L'aide du groupe DECRIT les deux champs (`aria-describedby` de chacun), et non le seul
+ *   `fieldset` : le defaut releve sur `st-date-range` ne se recopie pas.
+ * - L'erreur de plage (`erreurPlageDeMontants`) s'affiche sous le maximum, qui passe
+ *   `aria-invalid` ; `focus()` y va. Une lecture illisible reste sous son champ, et `focus()` va
+ *   au premier champ en erreur, sinon au minimum.
+ * - Catalogue retombe sur le francais (audit du 2026-09-27, D-29) : signale en developpement, sans
+ *   `lang`. Ses deux libelles nomment des champs de saisie, que partagent le nom de la devise et
+ *   les erreurs, dans la langue de la page.
+ */
+export declare class StAmountRange extends ContratDeChamp implements FormValueControl<PlageDeMontants> {
+  protected readonly libellesDesChamps: Signal<LibellesFormulaires>;
+  readonly value: import("@angular/core").ModelSignal<PlageDeMontants>;
+  /** Code ISO 4217 de la devise commune (« EUR »). */
+  readonly devise: import("@angular/core").InputSignal<string>;
+  readonly etiquettes: import("@angular/core").InputSignal<EtiquettesDePlage | null>;
+  private readonly fieldset;
+  private readonly champs;
+  /** Quitte au moins une fois : sans formulaire, rien d'autre ne dirait d'afficher les erreurs. */
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  protected readonly etiquettesLues: Signal<EtiquettesDePlage>;
+  /** La plage fautive se dit sous le maximum ; les autres erreurs du schema, au groupe. */
+  protected readonly erreursDuMaximum: Signal<import("@angular/forms/signals").ValidationError.WithOptionalFieldTree[]>;
+  protected readonly erreursDuGroupe: Signal<import("@angular/forms/signals").ValidationError.WithOptionalFieldTree[]>;
+  /** L'aide du groupe, quand il en a une : elle decrit chacun des deux champs. */
+  protected readonly decritPar: Signal<readonly string[]>;
+  protected changer(partie: keyof PlageDeMontants, montant: bigint | null): void;
+  protected quitter(): void;
+  /** Au maximum quand la plage est fautive, au premier champ illisible, sinon au minimum. */
+  focus(options?: FocusOptions): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StAmountRange, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StAmountRange, "st-amount-range", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "devise": {
+      "alias": "devise";
+      "required": true;
+      "isSignal": true;
+    };
+    "etiquettes": {
+      "alias": "etiquettes";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * Sortie du focus HORS d'un composant a calendrier : ferme le calendrier, marque le champ quitte.
+ *
+ * Un focus parti vers un element du composant n'est pas une sortie ; un focus parti vers un
+ * element exterieur (Tab) en est une, tranchee sur-le-champ. Les autres cas se tranchent APRES,
+ * sur l'element actif :
+ *
+ * - ⚠️ **Retrait du DOM** : changer de mois detruit le bouton du jour qui porte le focus, et
+ *   Chromium emet un `focusout` sans cible. Le calendrier rend le focus au nouveau jour dans le
+ *   meme rendu : la decision, prise en microtache, trouve le focus revenu, ou une cible retiree.
+ * - ⚠️ **Appui dans le composant** (WebKit, constat A1153 ; clic dans le blanc d'un calendrier
+ *   place dans un `st-dialog`) : le focus part sans cible, ou vers un ancetre focalisable
+ *   (`cdk-dialog-container`, `main[tabindex=-1]`), AVANT le clic, qui vient au relachement. La
+ *   decision attend le relachement ; le calendrier annule en plus `mousedown` hors de sa liste
+ *   d'annees, pour que le focus reste ou il est.
+ */
+declare class SortieDuComposant {
+  private readonly hote;
+  private readonly sortir;
+  private appui;
+  private enAttente;
+  /** Retire les ecouteurs d'un appui en cours ; `null` hors appui. */
+  private retirerLesEcouteurs;
+  private minuterie;
+  /**
+   * A construire dans un contexte d'injection (initialiseur de champ du composant) : un composant
+   * detruit en plein appui (une route quittee au relachement) ne laisse ni ecouteur sur le document
+   * ni minuterie (audit du 2026-09-27, Q-19).
+   */
+  constructor(hote: HTMLElement, sortir: () => void);
+  /** A brancher sur `(pointerdown)` de l'hote. */
+  surPointeur(): void;
+  /** A brancher sur `(focusout)` de l'hote. */
+  surFocusout(evenement: FocusEvent): void;
+  private trancher;
+}
+/** Les bornes d'une date, dites dans l'aide AVANT la saisie ; `null` sans borne. */
+declare function texteDesBornes(libelles: LibellesUi, locale: string, min: DateIso | null, max: DateIso | null): string | null;
+/** Les raccourcis en liste pleine largeur (planche 3a) ou en grille de deux colonnes (planche 3b). */
+type DispositionDesRaccourcis = 'liste' | 'grille';
+/** Un raccourci tel que le groupe l'affiche. */
+interface RaccourciAffiche {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly precision: string | null;
+  readonly choisi: boolean;
+}
+/**
+ * Raccourcis d'une date ou d'une periode (interne a `ui/formulaires`) : des BOUTONS A BASCULE
+ * (`aria-pressed`, ADR 0005, D66), pas des puces de filtre, dans un groupe nomme par son titre.
+ * Le raccourci choisi est celui dont la valeur est dans le modele : filet primaire double (rien ne
+ * bouge), texte primaire, coche ; la precision (« J-30 ») est un repere visuel, le nom est le
+ * libelle seul, stable quel que soit l'etat.
+ */
+declare class StRaccourcisDeDates {
+  readonly titre: import("@angular/core").InputSignal<string>;
+  readonly disposition: import("@angular/core").InputSignal<DispositionDesRaccourcis>;
+  readonly raccourcis: import("@angular/core").InputSignal<readonly RaccourciAffiche[]>;
+  readonly desactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** La cle du raccourci active. */
+  readonly choix: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly idDuTitre: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRaccourcisDeDates, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRaccourcisDeDates, "st-raccourcis-de-dates", never, {
+    "titre": {
+      "alias": "titre";
+      "required": true;
+      "isSignal": true;
+    };
+    "disposition": {
+      "alias": "disposition";
+      "required": false;
+      "isSignal": true;
+    };
+    "raccourcis": {
+      "alias": "raccourcis";
+      "required": true;
+      "isSignal": true;
+    };
+    "desactive": {
+      "alias": "desactive";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "choix": "choix";
+  }, never, never, true, never>;
+}
+/**
+ * Une date predefinie (« Fin de mois ») : l'application la calcule, le composant n'a pas
+ * d'horloge. `precision` est un repere visuel court, non lu.
+ */
+export interface RaccourciDeDate {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly precision?: string;
+  readonly date: DateIso;
+}
 /**
  * Date calendaire : un champ texte, et un calendrier pour qui prefere choisir.
  *
@@ -72,52 +465,141 @@ declare class StAmountField extends ContratDeChamp implements FormValueControl<b
  * `jj/mm/aaaa` ou `mm/dd/yyyy` — suit la langue courante, et il est dit en aide.
  *
  * ⚠️ **Le calendrier est une aide, pas la seule voie** : une date de naissance
- * se tape plus vite qu'elle ne se cherche mois par mois. Il s'ouvre sous le champ,
- * dans le flux de la page : pas de surcouche a positionner, rien de rogne dans
- * un dialogue, et le CDK n'entre pas dans les formulaires.
- *
- * Une date illisible ou inexistante — « 31/02/2026 » — garde le texte, laisse le
- * modele inchange et rend le formulaire invalide.
- */
-declare class StDateField extends ContratDeChamp implements FormValueControl<DateIso | null> {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    private readonly locale;
-    private readonly element;
-    private readonly injecteur;
-    readonly value: _angular_core.ModelSignal<string | null>;
-    /** Bornes du calendrier. Les memes que celles du schema : voir `erreurDate`. */
-    readonly dateMin: _angular_core.InputSignal<string | null>;
-    readonly dateMax: _angular_core.InputSignal<string | null>;
-    /** `bday` pour une date de naissance. */
-    readonly autocomplete: _angular_core.InputSignal<string | null>;
-    protected readonly ouvert: _angular_core.WritableSignal<boolean>;
-    protected readonly identifiantCalendrier: string;
-    private readonly calendrier;
-    private readonly bouton;
-    /**
-     * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe
-     * seul, rien ne le dirait, et une saisie illisible ne s'afficherait jamais.
-     */
-    protected readonly quitte: _angular_core.WritableSignal<boolean>;
-    protected readonly saisie: _angular_forms_signals.TransformedValueSignal<string>;
-    protected readonly aideLue: _angular_core.Signal<string>;
-    protected readonly erreursAffichees: _angular_core.Signal<readonly _starterlib_ui.ErreurAffichable[]>;
-    protected surSaisie(evenement: Event): void;
-    protected aLaSortieDuChamp(): void;
-    protected basculer(): void;
-    protected choisir(date: DateIso): void;
-    /** Echap rend le focus au bouton qui a ouvert le calendrier. */
-    protected fermer(rendreLeFocus: boolean): void;
-    protected aLaSortieDuComposant(evenement: FocusEvent): void;
-    private formater;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDateField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDateField, "st-date-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "dateMin": { "alias": "dateMin"; "required": false; "isSignal": true; }; "dateMax": { "alias": "dateMax"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
-}
-
+ * se tape plus vite qu'elle ne se cherche mois par mois. Il flotte sous le champ, dans la couche
+ * superieure du navigateur, comme la liste d'un `select` (ADR 0005, D132 : popover natif) : rien
+ * ne descend ni ne bouge autour, rien n'est rogne dans un dialogue, et le CDK n'entre toujours
+ * pas dans les formulaires.
+ *
+ * Une date illisible ou inexistante — « 31/02/2026 » — garde le texte, VIDE le modele
+ * (`null`, jamais la derniere date lisible : un appelant en `[(value)]` ne part pas avec une
+ * date perimee) et rend le formulaire invalide. Les bornes `dateMin` / `dateMax` se disent dans
+ * l'aide, avant la saisie ; Alt + Fleche bas ouvre le calendrier depuis le champ.
+ */
+export declare class StDateField extends ContratDeChamp implements FormValueControl<DateIso | null> {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  private readonly element;
+  private readonly injecteur;
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  /** Bornes du calendrier. Les memes que celles du schema : voir `erreurDate`. */
+  readonly dateMin: import("@angular/core").InputSignal<string | null>;
+  readonly dateMax: import("@angular/core").InputSignal<string | null>;
+  /** `bday` pour une date de naissance. */
+  readonly autocomplete: import("@angular/core").InputSignal<string | null>;
+  /** Annees du saut d'annee du calendrier (`{ min: 1900, max: 2026 }` pour une naissance). */
+  readonly annees: import("@angular/core").InputSignal<AnneesDuCalendrier | null>;
+  /** Dates predefinies, en boutons a bascule sous le champ (planche 3b, D66). */
+  readonly raccourcis: import("@angular/core").InputSignal<readonly RaccourciDeDate[]>;
+  /** `liste` (defaut) ou `grille` de deux colonnes (planche 3b). */
+  readonly dispositionDesRaccourcis: import("@angular/core").InputSignal<DispositionDesRaccourcis>;
+  /** Titre des raccourcis. Par defaut : « Dates predefinies ». */
+  readonly titreDesRaccourcis: import("@angular/core").InputSignal<string | null>;
+  /** Les raccourcis, dont celui qui est dans le modele (le choisi). */
+  protected readonly raccourcisAffiches: import("@angular/core").Signal<readonly RaccourciAffiche[]>;
+  protected readonly titreDesRaccourcisLu: import("@angular/core").Signal<string>;
+  /** Un raccourci pose sa date dans le modele ; le focus reste sur lui (`aria-pressed`). */
+  protected choisirUnRaccourci(cle: string): void;
+  protected readonly ouvert: import("@angular/core").WritableSignal<boolean>;
+  protected readonly identifiantCalendrier: string;
+  private readonly calendrier;
+  private readonly bouton;
+  /**
+   * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe
+   * seul, rien ne le dirait, et une saisie illisible ne s'afficherait jamais.
+   */
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  protected readonly saisie: import("@angular/forms/signals").TransformedValueSignal<string>;
+  /**
+   * La saisie est-elle illisible ? Le modele vaut alors `null` (la partie fautive, pour une
+   * plage), comme un champ vide : l'appelant sans formulaire distingue les deux par lui.
+   */
+  readonly lectureInvalide: import("@angular/core").Signal<boolean>;
+  protected readonly aideLue: import("@angular/core").Signal<string>;
+  /** Sortie du focus hors du composant : ferme le calendrier et marque le champ quitte. */
+  protected readonly sortie: SortieDuComposant;
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly import("@starterlib/ui/saisie").ErreurAffichable[]>;
+  protected surSaisie(evenement: Event): void;
+  /** Alt + Fleche bas ouvre le calendrier depuis le champ (motif APG d'une liste deroulante). */
+  protected surToucheDuChamp(evenement: KeyboardEvent): void;
+  /**
+   * Echap, calendrier ouvert, focus sur le champ ou le bouton : ferme et s'arrete ici (un
+   * `st-dialog` hote ne se ferme pas avec le calendrier). Depuis la grille, le calendrier l'a deja
+   * consommee.
+   */
+  protected surEchap(evenement: Event): void;
+  protected aLaSortieDuChamp(): void;
+  protected basculer(): void;
+  protected choisir(date: DateIso): void;
+  /** Echap (et le bouton qui referme) rend le focus au bouton qui a ouvert le calendrier. */
+  protected fermer(rendreLeFocus: boolean): void;
+  private formater;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDateField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDateField, "st-date-field", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMin": {
+      "alias": "dateMin";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMax": {
+      "alias": "dateMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "annees": {
+      "alias": "annees";
+      "required": false;
+      "isSignal": true;
+    };
+    "raccourcis": {
+      "alias": "raccourcis";
+      "required": false;
+      "isSignal": true;
+    };
+    "dispositionDesRaccourcis": {
+      "alias": "dispositionDesRaccourcis";
+      "required": false;
+      "isSignal": true;
+    };
+    "titreDesRaccourcis": {
+      "alias": "titreDesRaccourcis";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
 type Partie = 'debut' | 'fin';
+/**
+ * Une periode predefinie (« 30 derniers jours ») : l'application en calcule les dates, le composant
+ * n'a pas d'horloge. `precision` est un repere visuel court (« J-30 »), non lu.
+ */
+export interface RaccourciDePeriode {
+  readonly cle: string;
+  readonly libelle: string;
+  readonly precision?: string;
+  readonly plage: PlageDeDates;
+}
+/**
+ * `complete` : les deux champs et leurs calendriers. `resume` (planche 4, barre de filtres) : un
+ * bouton-champ qui dit la periode (« 1–30 sept. 2026 ») et deploie les champs dessous.
+ */
+export type VarianteDePlage = 'complete' | 'resume';
+/** Le style de l'etiquette de la variante `resume` (`micro-capitales` dans une barre de filtres). */
+export type PresentationDePlage = 'libelle' | 'micro-capitales';
 interface SaisieDePlage {
-    readonly debut: string;
-    readonly fin: string;
+  readonly debut: string;
+  readonly fin: string;
 }
 /**
  * Plage de dates : un debut, une fin, dans un groupe nomme par sa question.
@@ -137,62 +619,616 @@ interface SaisieDePlage {
  * lequel des champs est faux. L'erreur de lecture marque aussi son champ
  * `aria-invalid`, et lui seul.
  *
+ * ⚠️ **Chaque partie se lit seule** : une partie illisible passe a `null` dans le modele, l'autre
+ * y entre telle quelle (plus de « tout ou rien » : un debut efface ne reste pas dans le modele
+ * parce que la fin est illisible). Le formulaire reste invalide tant qu'une partie l'est.
+ *
+ * Chaque champ est decrit par l'aide du groupe et, en erreur, par ses messages (`aria-describedby`,
+ * `aria-errormessage`) ; une erreur du GROUPE (`required`) marque les deux champs. `focus()` va a
+ * la premiere partie en erreur, sinon au debut ; Echap rend le focus au bouton qui a ouvert.
+ *
  * L'obligation d'une borne est une regle du schema : `required` ne sait pas ce
  * qu'est une plage « vide ».
  */
-declare class StDateRange extends ContratDeChamp implements FormValueControl<PlageDeDates> {
-    protected readonly libelles: _angular_core.Signal<_starterlib_ui.LibellesUi>;
-    private readonly locale;
-    private readonly element;
-    private readonly injecteur;
-    readonly value: _angular_core.ModelSignal<PlageDeDates>;
-    readonly dateMin: _angular_core.InputSignal<string | null>;
-    readonly dateMax: _angular_core.InputSignal<string | null>;
-    /** Etiquettes des deux champs. Par defaut : « Date de debut », « Date de fin ». */
-    readonly libelleDebut: _angular_core.InputSignal<string | null>;
-    readonly libelleFin: _angular_core.InputSignal<string | null>;
-    protected readonly parties: readonly Partie[];
-    protected readonly ouvert: _angular_core.WritableSignal<Partie | null>;
-    protected readonly identifiants: {
-        readonly debut: `${string}-debut`;
-        readonly fin: `${string}-fin`;
-        readonly calendrier: `${string}-calendrier`;
-    };
-    private readonly calendrier;
-    /**
-     * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe
-     * seul, rien ne le dirait, et une saisie illisible ne s'afficherait jamais.
-     */
-    protected readonly quitte: _angular_core.WritableSignal<boolean>;
-    protected readonly saisie: _angular_forms_signals.TransformedValueSignal<SaisieDePlage>;
-    protected readonly etiquettes: _angular_core.Signal<{
-        debut: string;
-        fin: string;
-    }>;
-    protected readonly aideLue: _angular_core.Signal<string>;
-    /** Chaque erreur prefixee de sa partie, dans la langue courante. */
-    protected readonly erreursAffichees: _angular_core.Signal<readonly ErreurAffichable[]>;
-    protected readonly invalide: _angular_core.Signal<{
-        debut: boolean;
-        fin: boolean;
-    }>;
-    protected surSaisie(partie: Partie, evenement: Event): void;
-    protected aLaSortieDuChamp(): void;
-    protected basculer(partie: Partie): void;
-    protected bornes(partie: Partie): {
-        min: DateIso | null;
-        max: DateIso | null;
-    };
-    protected choisir(partie: Partie, date: DateIso): void;
-    protected fermer(partie: Partie): void;
-    protected aLaSortieDuComposant(evenement: FocusEvent): void;
-    /** `null` : vide. `undefined` : illisible. */
-    private lirePartie;
-    private formater;
-    /** La partie visee : celle d'une erreur de lecture, la fin pour une plage inversee. */
-    private partieDe;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StDateRange, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StDateRange, "st-date-range", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "dateMin": { "alias": "dateMin"; "required": false; "isSignal": true; }; "dateMax": { "alias": "dateMax"; "required": false; "isSignal": true; }; "libelleDebut": { "alias": "libelleDebut"; "required": false; "isSignal": true; }; "libelleFin": { "alias": "libelleFin"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
-}
-
-export { StAmountField, StDateField, StDateRange };
+export declare class StDateRange extends ContratDeChamp implements FormValueControl<PlageDeDates> {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  private readonly element;
+  private readonly injecteur;
+  readonly value: import("@angular/core").ModelSignal<PlageDeDates>;
+  readonly dateMin: import("@angular/core").InputSignal<string | null>;
+  readonly dateMax: import("@angular/core").InputSignal<string | null>;
+  /** Etiquettes des deux champs. Par defaut : « Date de debut », « Date de fin ». */
+  readonly libelleDebut: import("@angular/core").InputSignal<string | null>;
+  readonly libelleFin: import("@angular/core").InputSignal<string | null>;
+  /** Annees du saut d'annee du calendrier. */
+  readonly annees: import("@angular/core").InputSignal<AnneesDuCalendrier | null>;
+  /** Periodes predefinies, en boutons a bascule au-dessus des champs (planche 3a, D66). */
+  readonly raccourcis: import("@angular/core").InputSignal<readonly RaccourciDePeriode[]>;
+  /** `liste` (defaut, planche 3a) ou `grille` de deux colonnes (planche 3b). */
+  readonly dispositionDesRaccourcis: import("@angular/core").InputSignal<DispositionDesRaccourcis>;
+  /** Titre des raccourcis. Par defaut : « Periodes predefinies ». */
+  readonly titreDesRaccourcis: import("@angular/core").InputSignal<string | null>;
+  /** `complete` (defaut) ou `resume` : un bouton-champ qui deploie les champs (planche 4). */
+  readonly variante: import("@angular/core").InputSignal<VarianteDePlage>;
+  /** L'etiquette de la variante `resume`. */
+  readonly presentation: import("@angular/core").InputSignal<PresentationDePlage>;
+  protected readonly parties: readonly Partie[];
+  protected readonly ouvert: import("@angular/core").WritableSignal<Partie | null>;
+  /** Variante `resume` : les champs deployes sous le bouton-champ. */
+  protected readonly deploye: import("@angular/core").WritableSignal<boolean>;
+  protected readonly identifiants: {
+    readonly debut: `${string}-debut`;
+    readonly fin: `${string}-fin`;
+    readonly boutons: {
+      readonly debut: `${string}-bouton-debut`;
+      readonly fin: `${string}-bouton-fin`;
+    };
+    readonly calendrier: `${string}-calendrier`;
+    readonly resume: `${string}-resume`;
+    readonly libelleDuResume: `${string}-resume-libelle`;
+    readonly valeurDuResume: `${string}-resume-valeur`;
+    readonly detail: `${string}-detail`;
+  };
+  private readonly calendrier;
+  private readonly fieldset;
+  /** Les lignes des deux parties, ancres de leur calendrier flottant. */
+  private readonly lignes;
+  /**
+   * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe
+   * seul, rien ne le dirait, et une saisie illisible ne s'afficherait jamais.
+   */
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  protected readonly saisie: import("@angular/forms/signals").TransformedValueSignal<SaisieDePlage>;
+  /**
+   * La saisie est-elle illisible ? Le modele vaut alors `null` (la partie fautive, pour une
+   * plage), comme un champ vide : l'appelant sans formulaire distingue les deux par lui.
+   */
+  readonly lectureInvalide: import("@angular/core").Signal<boolean>;
+  protected readonly etiquettes: import("@angular/core").Signal<{
+    debut: string;
+    fin: string;
+  }>;
+  protected readonly aideLue: import("@angular/core").Signal<string>;
+  /** Les raccourcis, dont celui qui est dans le modele (le choisi). */
+  protected readonly raccourcisAffiches: import("@angular/core").Signal<readonly RaccourciAffiche[]>;
+  protected readonly titreDesRaccourcisLu: import("@angular/core").Signal<string>;
+  /**
+   * La periode dite par le bouton-champ de la variante `resume` : « 1–30 sept. 2026 » par `Intl`
+   * (formatRange, dans la langue de la page), une borne seule par « A partir du » ou « Jusqu’au »,
+   * rien choisi par « Choisir une periode ».
+   */
+  protected readonly periodeLue: import("@angular/core").Signal<string>;
+  protected readonly periodeChoisie: import("@angular/core").Signal<boolean>;
+  /**
+   * Sortie du focus hors du composant : ferme le calendrier (et le panneau de la variante resume)
+   * et marque le champ quitte.
+   */
+  protected readonly sortie: SortieDuComposant;
+  /**
+   * Chaque erreur prefixee de sa partie, dans la langue courante et avec SA ponctuation
+   * (`libelleEtMessage` : « Date de fin : ... », « End date: ... ») ; le separateur ecrit en dur
+   * mettait une espace insecable avant les deux-points jusqu'en anglais (audit UI du 2026-09-27,
+   * D-26).
+   */
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly ErreurAffichable[]>;
+  /** Parties en erreur. Une erreur du GROUPE (`required`, regle du schema) les vise toutes deux. */
+  private readonly enErreur;
+  protected readonly invalide: import("@angular/core").Signal<{
+    debut: boolean;
+    fin: boolean;
+  }>;
+  /**
+   * Description de chaque champ : l'aide du groupe, puis ses erreurs quand il est invalide (WCAG
+   * 3.3.1 et 3.3.3 au niveau du CHAMP, et non du seul `fieldset`). Les messages sont prefixes de
+   * leur partie : lus depuis un champ, ils disent lequel corriger.
+   */
+  protected readonly descriptions: import("@angular/core").Signal<{
+    debut: string | null;
+    fin: string | null;
+    erreur: `${string}-erreur` | null;
+  }>;
+  /** Un raccourci pose sa periode dans le modele ; le focus reste sur lui (`aria-pressed`). */
+  protected choisirUnRaccourci(cle: string): void;
+  /**
+   * Variante `resume` : le bouton-champ ouvre le panneau des champs, en couche flottante sous lui,
+   * et y porte le focus (le premier raccourci, sinon la date de debut) ; il le referme.
+   */
+  protected basculerLeResume(): void;
+  /** L'ancre du calendrier d'une partie : sa ligne (champ et bouton). */
+  protected ancreDe(partie: Partie): HTMLElement | null;
+  protected surSaisie(partie: Partie, evenement: Event): void;
+  /** Alt + Fleche bas ouvre le calendrier de la partie depuis son champ. */
+  protected surToucheDuChamp(partie: Partie, evenement: KeyboardEvent): void;
+  /**
+   * Echap, calendrier ouvert, focus sur un champ ou un bouton : ferme et s'arrete ici (un
+   * `st-dialog` hote ne se ferme pas avec le calendrier).
+   */
+  protected surEchap(evenement: Event): void;
+  protected aLaSortieDuChamp(): void;
+  protected basculer(partie: Partie): void;
+  protected bornes(partie: Partie): {
+    min: DateIso | null;
+    max: DateIso | null;
+  };
+  protected choisir(partie: Partie, date: DateIso): void;
+  /**
+   * Ferme le calendrier. Apres un choix, le focus revient au CHAMP (la date s'y relit et se
+   * corrige au clavier) ; apres Echap, au BOUTON qui a ouvert, comme `st-date-field`.
+   */
+  protected fermer(partie: Partie, versLeBouton?: boolean): void;
+  /**
+   * Appele par Signal Forms pour amener le focus sur un champ en erreur : la PREMIERE partie en
+   * erreur (la fin, si seule la fin l'est), sinon le debut.
+   */
+  focus(options?: FocusOptions): void;
+  /** `null` : vide. `undefined` : illisible. */
+  private lirePartie;
+  private formater;
+  /** La partie visee : celle d'une erreur de lecture, la fin pour une plage inversee. */
+  private partieDe;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StDateRange, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StDateRange, "st-date-range", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMin": {
+      "alias": "dateMin";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMax": {
+      "alias": "dateMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDebut": {
+      "alias": "libelleDebut";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleFin": {
+      "alias": "libelleFin";
+      "required": false;
+      "isSignal": true;
+    };
+    "annees": {
+      "alias": "annees";
+      "required": false;
+      "isSignal": true;
+    };
+    "raccourcis": {
+      "alias": "raccourcis";
+      "required": false;
+      "isSignal": true;
+    };
+    "dispositionDesRaccourcis": {
+      "alias": "dispositionDesRaccourcis";
+      "required": false;
+      "isSignal": true;
+    };
+    "titreDesRaccourcis": {
+      "alias": "titreDesRaccourcis";
+      "required": false;
+      "isSignal": true;
+    };
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "presentation": {
+      "alias": "presentation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * Heure d'horloge : un champ texte, au format de la langue courante.
+ *
+ * ```html
+ * <st-time-field libelle="Heure d'execution" heureMin="08:00" heureMax="18:00"
+ *   fuseau="Europe/Paris" [formField]="virement.heure" />
+ * <!-- schema : validate(chemin.heure, ({ value }) => erreurHeure(value(), { min: '08:00', max: '18:00' })) -->
+ * ```
+ *
+ * Le modele est une heure `HH:MM` (`HH:MM:SS` avec `secondes`) ou `null`, jamais un objet
+ * `Date` : une heure de rendez-vous n'a ni date ni fuseau. Le fuseau, s'il compte, se dit en aide
+ * (`fuseau`, un nom IANA) : il ne change pas la valeur.
+ *
+ * ⚠️ **Un champ texte, jamais `type="time"`** (D7 de l'audit de la vague 3, comme les dates ;
+ * ADR 0005, D110) : le champ natif suit la langue du NAVIGATEUR, pas celle de l'application, et son
+ * rendu varie d'un moteur a l'autre. Le format attendu — `hh:mm`, ou `hh:mm AM/PM` — et un exemple
+ * sont dits en aide.
+ *
+ * ⚠️ **Rien n'est devine** (`lireHeure`) : « 2:30 » sans marque, dans une locale a douze heures,
+ * est refuse ; « 2:30 pm » dans une locale a vingt-quatre heures aussi. « 1430 » se lit 14:30 :
+ * le pave numerique d'un telephone n'a pas de deux-points. Une saisie illisible garde le texte,
+ * vide le modele et rend le formulaire invalide, comme `st-date-field`.
+ */
+export declare class StTimeField extends ContratDeChamp implements FormValueControl<HeureIso | null> {
+  protected readonly libelles: import("@angular/core").Signal<LibellesUi>;
+  private readonly locale;
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  /** Bornes dites dans l'aide ; les memes que celles du schema (`erreurHeure`). */
+  readonly heureMin: import("@angular/core").InputSignal<string | null>;
+  readonly heureMax: import("@angular/core").InputSignal<string | null>;
+  /** Lire et rendre les secondes (`HH:MM:SS`). */
+  readonly secondes: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le fuseau de l'heure (IANA, `Europe/Paris`), nomme dans l'aide. */
+  readonly fuseau: import("@angular/core").InputSignal<string | null>;
+  readonly autocomplete: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Quitte au moins une fois. Relie a un formulaire, `touched` le dit ; employe seul, rien ne le
+   * dirait, et une saisie illisible ne s'afficherait jamais.
+   */
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  protected readonly saisie: import("@angular/forms/signals").TransformedValueSignal<string>;
+  /** La saisie est-elle illisible ? Le modele vaut alors `null`, comme un champ vide. */
+  readonly lectureInvalide: import("@angular/core").Signal<boolean>;
+  /** Le pave numerique la ou l'heure s'ecrit en chiffres ; le clavier complet pour « PM ». */
+  protected readonly clavier: import("@angular/core").Signal<"numeric" | "text">;
+  /** Le nom generique d'un fuseau se lit a une date d'aujourd'hui (util ne lit pas l'horloge). */
+  private readonly instantDuNomDeFuseau;
+  protected readonly aideLue: import("@angular/core").Signal<string>;
+  constructor();
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly import("@starterlib/ui/saisie").ErreurAffichable[]>;
+  protected surSaisie(evenement: Event): void;
+  protected aLaSortieDuChamp(): void;
+  private formater;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StTimeField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StTimeField, "st-time-field", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "heureMin": {
+      "alias": "heureMin";
+      "required": false;
+      "isSignal": true;
+    };
+    "heureMax": {
+      "alias": "heureMax";
+      "required": false;
+      "isSignal": true;
+    };
+    "secondes": {
+      "alias": "secondes";
+      "required": false;
+      "isSignal": true;
+    };
+    "fuseau": {
+      "alias": "fuseau";
+      "required": false;
+      "isSignal": true;
+    };
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * Nombre tape en chiffres : une quantite, une duree, un taux. Pas pour l'argent (`st-amount-field`,
+ * unites mineures).
+ *
+ * ```html
+ * <st-number-field libelle="Duree du pret" unite="mois" pas="12" [formField]="pret.duree" />
+ * <!-- schema : min(chemin.duree, 12) ; max(chemin.duree, 360) -->
+ * ```
+ *
+ * ⚠️ **Un champ texte, jamais `type="number"`** (GOV.UK) : le champ natif change la valeur a la
+ * molette, accepte « 1e5 », et lit la virgule ou non selon le navigateur. `inputmode` ouvre le
+ * pave numerique (`decimal` quand le champ admet des decimales).
+ *
+ * ⚠️ **Rien n'est devine** (`lireNombre`, les regles de `lireMontant`) : « 1.250 » en francais est
+ * refuse. Une saisie illisible garde le texte, vide le modele (aucun nombre perime, constat A1123)
+ * et rend le formulaire invalide ; `lectureInvalide` le dit a l'appelant sans formulaire. Des
+ * decimales dans un entier (`decimales` 0, par defaut) : « Saisissez un nombre entier. »
+ *
+ * - `pas` : les boutons - et + DANS le cadre, et le motif « spinbutton » de l'APG (fleches haut et
+ *   bas, Page haut et bas de dix pas, Debut et Fin aux bornes) ; sans `pas`, un champ texte
+ *   ordinaire. Les boutons, nommes « Diminuer <libelle> » et « Augmenter <libelle> » (D127), ne
+ *   prennent pas le focus : le clavier passe par les fleches. Un modele vide commence a la borne
+ *   basse (ou a 0).
+ * - Bornes : `min` et `max` du schema (Signal Forms les pose) ; le pas s'y arrete, et les messages
+ *   les disent. Le serveur les revalide (SEC-5).
+ * - `unite` : dans le cadre, apres la valeur (« mois », « % »), masquee au lecteur d'ecran qui la
+ *   lit en description.
+ *
+ * Le groupement « 1 234 » s'applique a la sortie du champ, jamais pendant la frappe.
+ */
+export declare class StNumberField extends ContratDeChampABornes<number | null> implements FormValueControl<number | null> {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  protected readonly idUnite: string;
+  readonly value: import("@angular/core").ModelSignal<number | null>;
+  /** Decimales admises : 0, un entier, par defaut. */
+  readonly decimales: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Pas des boutons et des fleches ; `null` (defaut) : ni boutons, ni motif « spinbutton ». */
+  readonly pas: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+  /** L'unite, dans le cadre apres la valeur (« mois », « % ») et lue en description. */
+  readonly unite: import("@angular/core").InputSignal<string | null>;
+  /** Quitte au moins une fois : sans formulaire, rien d'autre ne montrerait l'erreur de lecture. */
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  private averti;
+  /** Les decimales admises, en entier positif ; celles d'un pas plus fin sont signalees. */
+  protected readonly decimalesAdmises: import("@angular/core").Signal<number>;
+  protected readonly saisie: import("@angular/forms/signals").TransformedValueSignal<string>;
+  /** Vrai quand le texte saisi n'est pas un nombre (le modele vaut alors `null`). */
+  readonly lectureInvalide: import("@angular/core").Signal<boolean>;
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly import("@starterlib/ui/saisie").ErreurAffichable[]>;
+  protected readonly modifiable: import("@angular/core").Signal<boolean>;
+  protected readonly peutDiminuer: import("@angular/core").Signal<boolean>;
+  protected readonly peutAugmenter: import("@angular/core").Signal<boolean>;
+  /** La valeur et son unite, telles qu'un lecteur d'ecran les dit (« 24 mois »). */
+  protected readonly valeurLue: import("@angular/core").Signal<string | null>;
+  protected readonly uniteLue: import("@angular/core").Signal<string | null>;
+  protected readonly descriptionsDuControle: import("@angular/core").Signal<string[]>;
+  /** Un clic sur l'unite ou la marge du cadre donne le focus a la zone de frappe. */
+  protected surPressionDuCadre(evenement: MouseEvent): void;
+  protected surSaisie(evenement: Event): void;
+  /** Fleches, pages, Debut et Fin : seulement avec un pas, et sur un champ modifiable. */
+  protected surTouche(evenement: KeyboardEvent): void;
+  /** Avance de `nombreDePas` pas (negatif : recule) ; un modele vide part de la borne basse. */
+  protected avancer(nombreDePas: number): void;
+  protected aLaSortie(): void;
+  private poser;
+  private formater;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StNumberField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StNumberField, "st-number-field", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "decimales": {
+      "alias": "decimales";
+      "required": false;
+      "isSignal": true;
+    };
+    "pas": {
+      "alias": "pas";
+      "required": false;
+      "isSignal": true;
+    };
+    "unite": {
+      "alias": "unite";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
+}
+/**
+ * Curseur d'une valeur bornee : le montant ou la duree d'un simulateur, un plafond.
+ *
+ * ```html
+ * <st-range-slider libelle="Duree" unite="mois" pas="6" avecChamp [formField]="simulation.duree" />
+ * <!-- schema : min(chemin.duree, 6) ; max(chemin.duree, 84) -->
+ * ```
+ *
+ * ⚠️ **Le curseur natif d'abord** (`input type="range"`, FE-4) : clavier (fleches, Page haut et
+ * bas, Debut, Fin), toucher et lecteurs d'ecran le connaissent. La feuille ne change que sa peau :
+ * piste de 4 px, part remplie a l'encre primaire, pastille de 20 px dans une cible de 44 px.
+ *
+ * - Bornes : `min` et `max` du schema (Signal Forms les pose) ; 0 et 100 sans elles.
+ * - La valeur se lit en permanence, a cote du curseur (`output` relie au curseur, sans region
+ *   vivante : le curseur l'annonce deja par `aria-valuetext`, « 24 mois ») ; les bornes, dessous.
+ * - `avecChamp` : un `st-number-field` jumeau, pour une valeur precise (GOV.UK deconseille le
+ *   curseur seul), nomme « <libelle>, en chiffres » ; les deux restent synchronises.
+ * - `formaterValeur` : ce que la valeur affiche et fait lire (« 12 000 € ») ; par defaut le nombre
+ *   et son unite.
+ */
+export declare class StRangeSlider extends ContratDeChampABornes<number | null> implements FormValueControl<number | null> {
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui").LibellesUi>;
+  private readonly locale;
+  readonly value: import("@angular/core").ModelSignal<number | null>;
+  /** Le pas du curseur, 1 par defaut ; ses decimales sont celles de la valeur. */
+  readonly pas: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** L'unite, dite apres la valeur (« mois »). */
+  readonly unite: import("@angular/core").InputSignal<string | null>;
+  /** Un champ numerique jumeau, pour saisir une valeur precise. */
+  readonly avecChamp: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le texte de la valeur (« 12 000 € ») ; par defaut le nombre de la locale et l'unite. */
+  readonly formaterValeur: import("@angular/core").InputSignal<((valeur: number) => string) | null>;
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  private readonly enveloppe;
+  /** L'identifiant du curseur, que l'`output` cite dans son `for`. */
+  protected readonly idDuCurseur: import("@angular/core").Signal<string>;
+  protected readonly bas: import("@angular/core").Signal<number>;
+  protected readonly haut: import("@angular/core").Signal<number>;
+  protected readonly pasSur: import("@angular/core").Signal<number>;
+  protected readonly decimales: import("@angular/core").Signal<number>;
+  /** La part remplie de la piste, de 0 a 100 %. */
+  protected readonly partRemplie: import("@angular/core").Signal<string>;
+  protected readonly valeurLue: import("@angular/core").Signal<string>;
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly import("@starterlib/ui/saisie").ErreurAffichable[]>;
+  protected ecrire(valeur: number): string;
+  protected surCurseur(evenement: Event): void;
+  protected depuisLeChamp(valeur: number | null): void;
+  protected aLaSortie(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRangeSlider, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRangeSlider, "st-range-slider", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "pas": {
+      "alias": "pas";
+      "required": false;
+      "isSignal": true;
+    };
+    "unite": {
+      "alias": "unite";
+      "required": false;
+      "isSignal": true;
+    };
+    "avecChamp": {
+      "alias": "avecChamp";
+      "required": false;
+      "isSignal": true;
+    };
+    "formaterValeur": {
+      "alias": "formaterValeur";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
+}
+/** `tel` : numero complet, indicatif compris. `tel-national` : sans indicatif. */
+export type RemplissageDeTelephone = 'tel' | 'tel-national';
+/**
+ * Numero de telephone. La valeur du modele ne garde que les chiffres et le `+` de
+ * tete ; la saisie s'affiche telle qu'elle a ete tapee.
+ *
+ * ```html
+ * <st-phone-field libelle="Telephone portable" [formField]="contact.telephone" />
+ * <!-- schema : validate(chemin.telephone, ({ value }) => erreurTelephone(value())) -->
+ * ```
+ *
+ * ⚠️ **Le format est dit AVANT la saisie** : l'aide par defaut donne un exemple avec
+ * l'indicatif (« … par exemple +33 6 12 34 56 78. »), au lieu de n'expliquer le format
+ * qu'apres coup, par l'erreur.
+ *
+ * ⚠️ **Aucun formatage automatique.** Le groupement des chiffres depend du pays,
+ * et reformater pendant la frappe renvoie le curseur en fin de ligne. La saisie
+ * reste celle de la personne, espaces et points compris.
+ *
+ * ⚠️ **Une lettre tapee est dite, pas avalee en silence** : le modele n'en garde rien
+ * (`normaliserTelephone`), mais la FORME de la saisie (« 06 12 AB ») est une erreur de lecture,
+ * portee par `transformedValue` : relie a un formulaire, elle le rend invalide — le schema, qui ne
+ * voit que le modele normalise, ne pourrait pas la voir — et le numero ampute ne part pas ;
+ * employe seul, le champ la montre apres sa sortie.
+ *
+ * ⚠️ **Pas de selecteur de pays, pas de verification par pays.** Il faudrait une
+ * table des plans de numerotation, lourde et souvent perimee : c'est au serveur
+ * de dire si le numero existe (SEC-5). `erreurTelephone` ne verifie que la forme.
+ *
+ * `type="tel"`, et jamais `type="number"` : un numero n'est pas une quantite, et le
+ * champ numerique retire le zero de tete et le `+`. Chiffres tabulaires a zero barre (un numero
+ * se dicte), en ilot de gauche a droite.
+ */
+export declare class StPhoneField extends ControleDeSaisie {
+  private readonly libelles;
+  readonly autocomplete: import("@angular/core").InputSignal<RemplissageDeTelephone>;
+  /** Quitte au moins une fois : employe seul, rien d'autre ne dirait quand montrer la forme. */
+  private readonly quitte;
+  protected readonly aideLue: import("@angular/core").Signal<string>;
+  /**
+   * La saisie telle que tapee ; le modele n'en garde que les chiffres et le `+` de tete. Une forme
+   * qui n'est pas celle d'un numero est une erreur de LECTURE : elle entre dans la validite du
+   * formulaire. Une valeur changee de l'exterieur — remise a zero, pre-remplissage — l'emporte.
+   */
+  protected readonly saisie: import("@angular/forms/signals").TransformedValueSignal<string>;
+  /** Les erreurs du schema, puis celle de la forme de la saisie (une seule fois par genre). */
+  protected readonly erreursAffichees: import("@angular/core").Signal<readonly import("@starterlib/ui/saisie").ErreurAffichable[]>;
+  protected readonly afficherErreurs: import("@angular/core").Signal<boolean>;
+  protected surSaisie(evenement: Event): void;
+  protected aLaSortie(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StPhoneField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StPhoneField, "st-phone-field", never, {
+    "autocomplete": {
+      "alias": "autocomplete";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[stMeta]", "[stAide]", "[stIndication]"], true, never>;
+}
+type Fin = 'jamais' | 'date' | 'nombre';
+/** Ce que la personne a choisi, meme incomplet : le modele n'en recoit qu'une recurrence entiere. */
+interface Brouillon {
+  readonly frequence: FrequenceDeRecurrence;
+  readonly intervalle: number | null;
+  readonly jourDuMois: number | null;
+  readonly debut: DateIso | null;
+  readonly fin: Fin;
+  readonly jusquau: DateIso | null;
+  readonly nombre: number | null;
+}
+/**
+ * La recurrence d'un ordre permanent (lot 255) : frequence, intervalle, jour du mois, premiere
+ * echeance, fin ; et son recapitulatif en toutes lettres. Les libelles par defaut disent
+ * « echeance », jamais « virement » : un prelevement ou un rendez-vous se repetent aussi (audit du
+ * 2026-09-27, Q-26) ; une application les precise par `fournirLibellesFormulaires`.
+ *
+ * ```html
+ * <st-recurrence-field libelle="Periodicite du virement" [dateMin]="aujourdhui"
+ *   [formField]="ordre.recurrence" />
+ * ```
+ *
+ * - Un `st-fieldset` nomme par sa question : la frequence (`st-select`), l'intervalle
+ *   (`st-number-field`, son unite), le jour du mois (mensuel et annuel), la premiere echeance
+ *   (`st-date-field`), la fin (`st-radio-group` : jusqu'a nouvel ordre, a une date, apres un
+ *   nombre).
+ * - La regle des 29, 30 et 31 est l'AIDE du jour du mois, dite avant toute saisie.
+ * - Le recapitulatif (`decrireRecurrence`, `st-text`) DECRIT le groupe (`aria-describedby`) sans
+ *   region vivante : il ne s'annonce pas a chaque choix.
+ * - Le modele est une `Recurrence` (RFC 5545 : FREQ, INTERVAL, BYMONTHDAY, UNTIL, COUNT) des que le
+ *   premiere echeance est connue, `null` avant ; les choix incomplets sont gardes.
+ * - Catalogue retombe sur le francais (audit du 2026-09-27, D-29) : `lang="fr"` sur ce qu'il ecrit
+ *   seul, le jour du mois, la fin et le titre du recapitulatif. Le reste garde la langue de la
+ *   page : la question et l'aide de l'application, les champs de saisie (leurs erreurs et le
+ *   bouton du calendrier viennent du tronc), la frequence (son option vide aussi) et le
+ *   recapitulatif, ecrit dans la locale.
+ */
+export declare class StRecurrenceField extends ContratDeChamp implements FormValueControl<Recurrence | null> {
+  private readonly locale;
+  private readonly catalogue;
+  protected readonly libellesDesChamps: Signal<LibellesFormulaires>;
+  /** `fr` quand le catalogue retombe sur le francais, `null` sinon (D-29). */
+  protected readonly langueDeRepli: Signal<string | null>;
+  readonly value: import("@angular/core").ModelSignal<Recurrence | null>;
+  /** La premiere echeance possible (aujourd'hui, pour un ordre a venir) : l'application la sait. */
+  readonly dateMin: import("@angular/core").InputSignal<string | null>;
+  private readonly frequenceChamp;
+  private readonly debutChamp;
+  protected readonly idDuRecapitulatif: string;
+  protected readonly quitte: import("@angular/core").WritableSignal<boolean>;
+  /** Le brouillon suit le modele quand il change d'ailleurs, et garde ses choix quand il est vide. */
+  protected readonly brouillon: import("@angular/core").WritableSignal<Brouillon>;
+  protected readonly optionsDeFrequence: Signal<readonly OptionDeListe[]>;
+  protected readonly optionsDeJour: Signal<readonly OptionDeListe[]>;
+  protected readonly optionsDeFin: Signal<readonly OptionRadio[]>;
+  protected readonly avecJourDuMois: Signal<boolean>;
+  protected readonly jourChoisi: Signal<string>;
+  protected readonly unite: Signal<string>;
+  protected readonly recapitulatif: Signal<string | null>;
+  protected readonly decritPar: Signal<readonly string[]>;
+  protected modifier(partie: Partial<Brouillon>): void;
+  protected choisirLaFrequence(valeur: string): void;
+  protected choisirLeJour(valeur: string): void;
+  protected choisirLaFin(valeur: string): void;
+  protected quitter(): void;
+  /** A la premiere echeance quand elle manque, sinon a la frequence. */
+  focus(options?: FocusOptions): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StRecurrenceField, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StRecurrenceField, "st-recurrence-field", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "dateMin": {
+      "alias": "dateMin";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+export type { DispositionDesRaccourcis };