@starterlib/ui 0.10.14 → 0.11.1

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

@@ -1,8 +1,9 @@
 import { ApiError, EtatDeCeremonie, LectureDeCeremonie, MoyenDeCeremonie, TonSemantique } from "@starterlib/util";
 import * as i0 from "@angular/core";
-import { InjectionToken, Signal } from "@angular/core";
-import { AnnonceLocale, Icone, NiveauDeTitre } from "@starterlib/ui";
+import { InjectionToken, Provider, Signal } from "@angular/core";
+import { AnnonceLocale, CatalogueDuPointDEntree, Icone, NiveauDeTitre, NomDIcone } from "@starterlib/ui";
 import { DispositionDActions, ErreurAffichable } from "@starterlib/ui/saisie";
+import { TonDeStatut } from "@starterlib/ui/indicateurs";
 /**
  * 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`).
@@ -64,7 +65,7 @@ export declare class StRefusal {
   private readonly decompte;
   protected readonly variante: import("@angular/core").Signal<import("@starterlib/util").VarianteDErreur>;
   private readonly rejouableSelonLaTable;
-  protected readonly ton: import("@angular/core").Signal<"avertissement" | "danger">;
+  protected readonly ton: import("@angular/core").Signal<"avertissement" | "erreur">;
   protected readonly titreLu: import("@angular/core").Signal<string | null>;
   /** Les secondes d'un 429, quand le serveur les donne. */
   protected readonly attente: import("@angular/core").Signal<number | null>;
@@ -164,7 +165,7 @@ export declare class StOutcome {
   readonly niveauDuTitre: import("@angular/core").InputSignal<NiveauDeTitre>;
   readonly disposition: import("@angular/core").InputSignal<DispositionDIssue>;
   protected readonly ton: import("@angular/core").Signal<TonSemantique>;
-  protected readonly icone: import("@angular/core").Signal<"horloge" | "badge-coche" | "bouclier-coche" | "cercle-alerte" | "cercle-coche" | "cercle-croix" | "cercle-info" | "cercle-question" | "cloche" | "epingle" | "etoile" | "grille" | "marque-page" | "octogone-alerte" | "triangle-alerte">;
+  protected readonly icone: import("@angular/core").Signal<"essai" | "horloge" | "badge-coche" | "bouclier-coche" | "cercle-alerte" | "cercle-coche" | "cercle-croix" | "cercle-info" | "cercle-question" | "cloche" | "epingle" | "etoile" | "grille" | "marque-page" | "octogone-alerte" | "triangle-alerte">;
   /** Le mot de l'issue, lu avant le titre. */
   protected readonly mot: import("@angular/core").Signal<string>;
   protected readonly etiquetteDeReferenceLue: import("@angular/core").Signal<string>;
@@ -967,7 +968,7 @@ export declare class StRecoveryCodes {
   protected readonly tousLesCodes: import("@angular/core").Signal<string>;
   protected readonly raisonDeLAttente: import("@angular/core").Signal<string>;
   /** Le compteur alerte quand il ne reste presque plus de codes. */
-  protected readonly tonDuCompteur: import("@angular/core").Signal<"avertissement" | "danger" | "neutre">;
+  protected readonly tonDuCompteur: import("@angular/core").Signal<"avertissement" | "neutre" | "danger">;
   constructor();
   protected copier(): void;
   /** Garde du double clic : `chargement` avale deja les clics du bouton, la methode aussi. */
@@ -1032,5 +1033,264 @@ export declare class StRecoveryCodes {
     "regeneration": "regeneration";
   }, never, never, true, never>;
 }
+/**
+ * La demande de modification d'une valeur gouvernee (P08-13) : ce que le modele d'un formulaire
+ * Signal Forms porte, la valeur proposee et son motif.
+ *
+ * ```ts
+ * readonly demande = form(signal<DemandeDeModification<bigint | null>>({ valeur: null, motif: '' }),
+ *   (chemin) => {
+ *     required(chemin.valeur);
+ *     validate(chemin.valeur, ({ value }) => erreurHorsPlage(value(), { min: 10_000n, max: 500_000n }));
+ *     required(chemin.motif);
+ *     validate(chemin.motif, ({ value }) => erreurDeMotif(value(), 20));
+ *   });
+ * ```
+ */
+export interface DemandeDeModification<TValeur> {
+  readonly valeur: TValeur;
+  readonly motif: string;
+}
+/**
+ * Le cycle de vie d'une demande, calcule par le SERVEUR, jamais par le composant : `brouillon`
+ * (saisie), `previsualise` (l'effet calcule est montre), `attente-seconde-validation`,
+ * `seconde-validation-suspendue` (la regle a deux personnes ne s'applique pas, l'effectif le dit),
+ * `programme` (effet differe, a sa date), `publie`, `refuse`.
+ */
+export type EtatDeDemande = 'brouillon' | 'previsualise' | 'attente-seconde-validation' | 'seconde-validation-suspendue' | 'programme' | 'publie' | 'refuse';
+/** Le sens de l'effet, fourni par le serveur : un assouplissement attend, un resserrement non. */
+export type SensDeDemande = 'assouplissement' | 'resserrement';
+/** L'effet d'une demande, fourni : immediat, ou differe a sa date (ISO 8601, avec son decalage). */
+export type EffetDeDemande = {
+  readonly nature: 'immediat';
+  readonly sens: SensDeDemande;
+} | {
+  readonly nature: 'differe';
+  readonly sens: SensDeDemande;
+  readonly date: string;
+};
+/** La plage de surete, telle que l'application l'ecrit (« 100,00 € », « 5 000,00 € »). */
+export interface PlageDeDemande {
+  readonly min: string;
+  readonly max: string;
+}
+/** Un refus du serveur : l'erreur telle que le noyau la rend, et le message que l'application en tire. */
+export interface RefusDeDemande {
+  readonly erreur: ApiError;
+  readonly message: string;
+  /** Un code que l'application ne connait pas : la trace se montre (`st-refusal`). */
+  readonly codeInconnu?: boolean;
+}
+/** Une valeur hors de sa plage : la borne franchie, que le message cite. */
+export type ErreurDePlage<TValeur extends number | bigint> = {
+  readonly kind: 'min';
+  readonly min: TValeur;
+} | {
+  readonly kind: 'max';
+  readonly max: TValeur;
+};
+/** Les bornes d'une valeur gouvernee, livrees par le serveur ; l'une ou l'autre peut manquer. */
+export interface BornesDeValeur<TValeur extends number | bigint> {
+  readonly min?: TValeur;
+  readonly max?: TValeur;
+}
+/**
+ * La borne qu'une valeur franchit, ou `null` : pour un nombre comme pour un montant en unites
+ * mineures (`bigint`), dont `st-amount-field` dit la borne en devise (« au plus 5 000,00 € »).
+ * Une valeur absente n'en franchit aucune : `required()` la refuse.
+ *
+ * ```ts
+ * validate(chemin.valeur, ({ value }) => erreurHorsPlage(value(), { min: 10_000n, max: 500_000n }));
+ * ```
+ *
+ * Pour un nombre saisi par `st-number-field`, `min()` et `max()` de Signal Forms font de meme ET
+ * posent les bornes du champ, ou ses pas s'arretent.
+ */
+export declare function erreurHorsPlage<TValeur extends number | bigint>(valeur: TValeur | null, bornes: BornesDeValeur<TValeur>): ErreurDePlage<TValeur> | null;
+/** La longueur minimale d'un motif quand l'application n'en donne pas : de quoi dire pourquoi. */
+export declare const MOTIF_MINIMUM = 10;
+/**
+ * L'erreur du motif d'une demande, ou `null` : obligatoire, et `minimum` caracteres au moins SANS
+ * les blancs de bord (dix espaces ne disent rien). Les genres sont ceux du socle (`required`,
+ * `minLength`) : le message est celui de tous les champs.
+ *
+ * ```ts
+ * required(chemin.motif);
+ * validate(chemin.motif, ({ value }) => erreurDeMotif(value(), 20));
+ * ```
+ */
+export declare function erreurDeMotif(valeur: string, minimum?: number): {
+  readonly kind: 'required';
+} | {
+  readonly kind: 'minLength';
+  readonly minLength: number;
+} | null;
+/**
+ * Les libelles de `@starterlib/ui/parcours` (P08-13) : le catalogue par point d'entree (AD-10,
+ * D154), comme ceux des donnees et des graphiques. La langue suit celle du dictionnaire du tronc ;
+ * les patrons plus anciens du point d'entree lisent encore le dictionnaire du tronc.
+ */
+export interface LibellesParcours {
+  /** Le mot de chaque etat d'une demande (`st-change-request`), sur sa pastille. */
+  readonly etatsDeDemande: Readonly<Record<EtatDeDemande, string>>;
+  /** Le mot de chaque sens d'effet. */
+  readonly sensDeDemande: Readonly<Record<SensDeDemande, string>>;
+  readonly valeurActuelle: string;
+  readonly plageAutorisee: string;
+  /** La plage de surete, ses bornes deja ecrites par l'application (« de 100,00 € a 5 000,00 € »). */
+  readonly plage: (min: string, max: string) => string;
+  readonly effet: string;
+  readonly effetImmediat: string;
+  readonly effetDiffere: string;
+  readonly priseDEffet: string;
+  /** La legende du groupe de la valeur proposee et du motif. */
+  readonly proposition: string;
+  /** Le titre de l'emplacement ou l'application montre l'effet calcule par le serveur. */
+  readonly previsualisation: string;
+  /** Pourquoi la saisie est figee apres une previsualisation ou un refus. */
+  readonly rouvrirPourModifier: string;
+  /** Pourquoi la saisie est figee une fois la demande envoyee. */
+  readonly demandeEnvoyee: string;
+  readonly attenteDeSecondeValidation: string;
+  readonly secondeValidationSuspendue: string;
+  readonly previsualiser: string;
+  readonly soumettre: string;
+  readonly modifier: string;
+  readonly annuler: string;
+  /** L'annonce d'un changement d'etat (« Demande : programmee »). */
+  readonly etatDeLaDemande: (etat: string) => string;
+}
+export declare const LIBELLES_PARCOURS_FR: LibellesParcours;
+export declare const LIBELLES_PARCOURS_EN: LibellesParcours;
+/**
+ * Les catalogues du parcours par langue (sous-etiquette primaire : `fr`, `en`). Une application qui
+ * ajoute une langue au dictionnaire du tronc ajoute la sienne ici, par
+ * `fournirLibellesParcours({ de: ... })`.
+ */
+export declare const ST_LIBELLES_PARCOURS: InjectionToken<Readonly<Record<string, LibellesParcours>>>;
+/** Ajoute (ou remplace) des catalogues du parcours, par langue. */
+export declare function fournirLibellesParcours(catalogues: Readonly<Record<string, LibellesParcours>>): Provider;
+/**
+ * Le catalogue de la langue du dictionnaire du tronc ; le francais quand la langue n'en a pas, un
+ * repli signale en developpement (D-29). A appeler dans un contexte d'injection.
+ */
+export declare function libellesDuParcours(): Signal<LibellesParcours>;
+/**
+ * Le catalogue du parcours ET la langue de son repli (`catalogueDuPointDEntree`) : `lang` de ce qu'il
+ * ecrit seul (D-29). A appeler dans un contexte d'injection.
+ */
+export declare function catalogueDuParcours(): Signal<CatalogueDuPointDEntree<LibellesParcours>>;
+/**
+ * Demander la modification d'une valeur GOUVERNEE (P08-13) : un plafond, un seuil, une duree. Un
+ * seul patron, au lieu d'ecrans qui reinventeraient la plage de surete, le delai, le motif et la
+ * previsualisation.
+ *
+ * ```html
+ * <form [stForm]="demande" [envoyerAvec]="envoyer">
+ *   <st-change-request titre="Plafond de retrait quotidien" [etat]="etat()" [effet]="effet()"
+ *     [plage]="{ min: '100,00 €', max: '5 000,00 €' }" [refus]="refus()"
+ *     (modification)="etat.set('brouillon')" (annulation)="annuler()">
+ *     <st-money actuelle [valeur]="plafond()" />
+ *     <st-amount-field champ libelle="Nouveau plafond" devise="EUR" [formField]="demande.valeur" />
+ *     <st-textarea motif libelle="Motif" [formField]="demande.motif" />
+ *     <div previsualisation>...</div>
+ *   </st-change-request>
+ * </form>
+ * ```
+ *
+ * - **Le serveur juge seul** : il livre les bornes, le sens et la date de l'effet, et l'etat (sept,
+ *   chacun en mot et en forme) ; le composant ne calcule RIEN de metier. La regle a deux personnes
+ *   peut etre suspendue : le composant le montre, il ne le decide pas.
+ * - **Un formulaire Signal Forms** de l'application (`form[stForm]`), ou les champs sont PROJETES :
+ *   la valeur proposee (`[champ]`) et le motif (`[motif]`), lies par `[formField]`. Les regles du
+ *   schema rendent la plage infranchissable (`min()` et `max()`, ou `erreurHorsPlage` pour un
+ *   montant ; le message cite la borne) et le motif obligatoire (`erreurDeMotif`). Le recapitulatif
+ *   d'erreurs est le sien ; un envoi invalide ne part pas.
+ * - **Une action principale** qui ENVOIE le formulaire : « Previsualiser » au brouillon,
+ *   « Soumettre la demande » une fois l'effet montre ; `envoyerAvec` fait l'appel selon l'etat. Le
+ *   double clic est avale (`chargement`), la cle d'idempotence posee par l'intercepteur du socle.
+ * - Apres la previsualisation, la saisie se fige (« Modifier la demande » la rouvre : `modification`)
+ *   ; envoyee, elle ne change plus, et « Annuler la demande » reste (`annulation`).
+ * - Un changement d'etat s'annonce ; un refus prend le focus (`st-refusal`).
+ */
+export declare class StChangeRequest {
+  protected readonly catalogue: import("@angular/core").Signal<import("@starterlib/ui").CatalogueDuPointDEntree<import("@starterlib/ui/parcours").LibellesParcours>>;
+  protected readonly annonce: AnnonceLocale;
+  /** L'envoi du formulaire qui l'entoure (`form[stForm]`) : son recapitulatif et son chargement. */
+  protected readonly envoi: import("@starterlib/ui/saisie").EtatDEnvoi | null;
+  /** Ce qui se modifie (« Plafond de retrait quotidien »), deja traduit. */
+  readonly titre: import("@angular/core").InputSignal<string>;
+  /** 2 en tete de page, 3 ou 4 dans une section. */
+  readonly niveauDuTitre: import("@angular/core").InputSignal<2 | 3 | 4>;
+  /** L'etat calcule par le serveur. */
+  readonly etat: import("@angular/core").InputSignal<EtatDeDemande>;
+  /** Le sens et la nature de l'effet, fournis par le serveur. */
+  readonly effet: import("@angular/core").InputSignal<EffetDeDemande | null>;
+  /** La plage de surete, ses bornes ecrites par l'application. */
+  readonly plage: import("@angular/core").InputSignal<PlageDeDemande | null>;
+  /** Le refus du serveur, montre a l'etat `refuse`. */
+  readonly refus: import("@angular/core").InputSignal<RefusDeDemande | null>;
+  /** « Modifier la demande » : apres une previsualisation ou un refus, la saisie se rouvre. */
+  readonly modification: import("@angular/core").OutputEmitterRef<void>;
+  /** « Annuler la demande » : une demande envoyee, encore en attente ou programmee. */
+  readonly annulation: import("@angular/core").OutputEmitterRef<void>;
+  protected readonly identifiants: {
+    readonly titre: `${string}-titre`;
+    readonly gel: `${string}-gel`;
+    readonly previsualisation: `${string}-previsualisation`;
+  };
+  protected readonly pastille: import("@angular/core").Signal<{
+    readonly ton: TonDeStatut;
+    readonly icone: NomDIcone;
+  }>;
+  protected readonly libelleDEtat: import("@angular/core").Signal<string>;
+  /** La saisie se fige des que l'effet est montre : une valeur changee ne serait plus celle montree. */
+  protected readonly fige: import("@angular/core").Signal<boolean>;
+  protected readonly envoyee: import("@angular/core").Signal<boolean>;
+  protected readonly rouvrable: import("@angular/core").Signal<boolean>;
+  /** Pourquoi la saisie est figee : dite en aide du groupe, jamais tue. */
+  protected readonly raisonDuGel: import("@angular/core").Signal<string | null>;
+  protected readonly explication: import("@angular/core").Signal<string | null>;
+  protected readonly enCours: import("@angular/core").Signal<boolean>;
+  /** Le recapitulatif sous le titre : un niveau de plus, 4 au plus. */
+  protected readonly niveauDuRecapitulatif: import("@angular/core").Signal<3 | 4>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StChangeRequest, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StChangeRequest, "st-change-request", never, {
+    "titre": {
+      "alias": "titre";
+      "required": true;
+      "isSignal": true;
+    };
+    "niveauDuTitre": {
+      "alias": "niveauDuTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "etat": {
+      "alias": "etat";
+      "required": true;
+      "isSignal": true;
+    };
+    "effet": {
+      "alias": "effet";
+      "required": false;
+      "isSignal": true;
+    };
+    "plage": {
+      "alias": "plage";
+      "required": false;
+      "isSignal": true;
+    };
+    "refus": {
+      "alias": "refus";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "modification": "modification";
+    "annulation": "annulation";
+  }, never, ["[actuelle]", "[champ]", "[motif]", "[previsualisation]"], true, never>;
+}
 
 export {};