@starterlib/ui 0.11.7 → 0.13.0

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

@@ -1861,6 +1861,123 @@ export declare class StFreshness {
     "perimee": "perimee";
   }, never, never, true, never>;
 }
+/** Une image a inspecter : son contenu, charge par l'application, et ce qu'elle montre, deja traduit. */
+export interface ImageAInspecter {
+  /** Le contenu (`Blob`), charge par l'application par `@starterlib/core`, sans cache. */
+  readonly contenu: Blob;
+  /** Ce que montre l'image (« Recto de la piece »), son nom au lecteur d'ecran et sa legende. */
+  readonly libelle: string;
+}
+/** Les bornes et les pas du zoom (1 : l'image ajustee a la largeur du panneau) et du contraste. */
+export declare const BORNES_DE_LA_VISIONNEUSE: {
+  readonly zoom: {
+    readonly min: 0.5;
+    readonly max: 4;
+    readonly pas: 0.25;
+  };
+  readonly contraste: {
+    readonly min: 0.5;
+    readonly max: 2;
+    readonly pas: 0.25;
+  };
+};
+type EtatDuPanneau = 'chargement' | 'prete' | 'illisible';
+/**
+ * Visionneuse de pieces (P08-17 d'Aplomb, DEC-090) : une image, ou deux cote a cote (recto et verso,
+ * piece et selfie), a inspecter a l'ecran SANS la telecharger.
+ *
+ * ```html
+ * <st-image-viewer libelle="Piece d'identite" [images]="pieces()" filigrane="M. Operateur, 14/10/2026" />
+ * ```
+ *
+ * - **Aucune adresse vers l'image** : le contenu (`Blob`, charge par l'application par
+ *   `@starterlib/core`, la piece etant servie sans cache par le serveur) est decode une fois en
+ *   `ImageBitmap`, dessine dans un canevas, puis le bitmap est ferme : une seule image decodee par
+ *   panneau, aucune `ObjectURL` (ni lien, ni `blob:` a autoriser dans la politique de securite du
+ *   contenu), aucun bouton de telechargement, aucun menu contextuel « Enregistrer l'image ». Les
+ *   canevas sont vides a la destruction, et a chaque changement d'images.
+ * - **Zoom, rotation, contraste** a la barre d'outils et au clavier, communs aux deux panneaux ; le
+ *   defilement de l'un suit celui de l'autre. Raccourcis : `+` et `-` (zoom), `r` et `Maj+r`
+ *   (rotation a droite et a gauche), `c` et `Maj+c` (contraste), `0` (vue d'origine) ; les fleches
+ *   font defiler le panneau qui a le focus. Chaque changement s'annonce poliment.
+ * - **Filigrane** (`filigrane` : identite de l'operateur et date, texte fourni) par-dessus chaque
+ *   panneau, a l'ecran comme a l'impression ; les images, elles, ne s'impriment pas.
+ * - Rien n'est stocke dans le navigateur.
+ */
+export declare class StImageViewer {
+  /** Une ou deux images ; au-dela de deux, les suivantes sont ignorees. */
+  readonly images: import("@angular/core").InputSignal<readonly ImageAInspecter[]>;
+  /** Le nom du groupe (« Piece d'identite de la demande 42 »). */
+  readonly libelle: import("@angular/core").InputSignal<string>;
+  /** Le texte du filigrane (identite de l'operateur, date), deja traduit ; `null` : aucun. */
+  readonly filigrane: import("@angular/core").InputSignal<string | null>;
+  protected readonly libelles: import("@angular/core").Signal<import("@starterlib/ui/donnees").LibellesDonnees>;
+  protected readonly bornes: {
+    readonly zoom: {
+      readonly min: 0.5;
+      readonly max: 4;
+      readonly pas: 0.25;
+    };
+    readonly contraste: {
+      readonly min: 0.5;
+      readonly max: 2;
+      readonly pas: 0.25;
+    };
+  };
+  protected readonly zoom: import("@angular/core").WritableSignal<number>;
+  protected readonly rotation: import("@angular/core").WritableSignal<number>;
+  protected readonly contraste: import("@angular/core").WritableSignal<number>;
+  protected readonly etats: import("@angular/core").WritableSignal<readonly EtatDuPanneau[]>;
+  private readonly dimensions;
+  private readonly ajustements;
+  private readonly toiles;
+  private readonly defilements;
+  protected readonly annonce: AnnonceLocale;
+  protected readonly identifiantDeLAide: string;
+  /** Une generation par jeu d'images : un decodage en retard ne dessine jamais dans un canevas reutilise. */
+  private generation;
+  private synchronisationEnCours;
+  protected readonly affichees: import("@angular/core").Signal<ImageAInspecter[]>;
+  protected readonly transformation: import("@angular/core").Signal<string>;
+  protected readonly filtre: import("@angular/core").Signal<string>;
+  /** Taille affichee du canevas et de sa boite (la boite echange ses cotes a 90 et 270 degres). */
+  protected readonly mesures: import("@angular/core").Signal<({
+    largeur: number;
+    hauteur: number;
+    boiteLargeur: number;
+    boiteHauteur: number;
+  } | null)[]>;
+  constructor();
+  private dessiner;
+  protected zoomer(sens: 1 | -1): void;
+  protected tourner(degres: 90 | -90): void;
+  protected contraster(sens: 1 | -1): void;
+  protected reinitialiser(): void;
+  protected pourcentage(valeur: number): number;
+  private annoncerLaVue;
+  protected auClavier(evenement: KeyboardEvent): void;
+  /** Le defilement d'un panneau, reporte en proportion sur l'autre (une seule fois, sans rebond). */
+  protected synchroniser(indice: number): void;
+  protected interdireLeMenu(evenement: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StImageViewer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StImageViewer, "st-image-viewer", never, {
+    "images": {
+      "alias": "images";
+      "required": true;
+      "isSignal": true;
+    };
+    "libelle": {
+      "alias": "libelle";
+      "required": true;
+      "isSignal": true;
+    };
+    "filigrane": {
+      "alias": "filigrane";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /**
  * Les libelles de `@starterlib/ui/donnees` (P08-08) : le catalogue par point d'entree (AD-10, D154),
  * comme ceux de la navigation et des formulaires. La langue suit celle du dictionnaire du tronc.
@@ -1874,6 +1991,20 @@ export interface LibellesDonnees {
   readonly perimeeDepuis: (duree: string) => string;
   /** Le nom de la donnee devant son etat, espace finale comprise (« Positions : »). */
   readonly libelleDeLaDonnee: (libelle: string) => string;
+  /** `st-image-viewer` (P08-17) : le nom de sa barre d'outils. */
+  readonly outilsDeLaVisionneuse: string;
+  readonly reduire: string;
+  readonly agrandir: string;
+  readonly tournerAGauche: string;
+  readonly tournerADroite: string;
+  readonly moinsDeContraste: string;
+  readonly plusDeContraste: string;
+  readonly vueDOrigine: string;
+  /** Les raccourcis de la visionneuse, en aide visible sous la barre. */
+  readonly raccourcisDeLaVisionneuse: string;
+  /** L'annonce de la vue : zoom et contraste en pour cent, rotation en degres. */
+  readonly etatDeLaVue: (zoom: number, rotation: number, contraste: number) => string;
+  readonly imageIllisible: string;
 }
 export declare const LIBELLES_DONNEES_FR: LibellesDonnees;
 export declare const LIBELLES_DONNEES_EN: LibellesDonnees;

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

@@ -2,7 +2,7 @@ import * as i0 from "@angular/core";
 import { InjectionToken, Provider, Signal } from "@angular/core";
 import { AnnonceLocale, CatalogueDuPointDEntree } from "@starterlib/ui";
 import { ColonneDeTableau } from "@starterlib/ui/listes";
-import { UniteDeTemps } from "@starterlib/util/graduations";
+import { Graduations, UniteDeTemps } from "@starterlib/util/graduations";
 /**
  * Les donnees d'un graphique (P08-07), telles que l'API les donne : des instants ISO 8601 et des
  * valeurs en CHAINE DECIMALE, jamais en flottant (regles-front §2). L'echelle se calcule sur des
@@ -48,6 +48,16 @@ export interface MarqueurDeGraphique {
   readonly instant: string;
   readonly libelle: string;
 }
+/**
+ * Une classe d'histogramme (P08-18), de preference calculee par le SERVEUR sur toutes ses donnees :
+ * ses bornes en chaines decimales exactes, de `debut` (compris) a `fin` (exclue, sauf pour la
+ * derniere classe), et son effectif, un entier positif ou nul.
+ */
+export interface ClasseDHistogramme {
+  readonly debut: string;
+  readonly fin: string;
+  readonly effectif: number;
+}
 /**
  * Les libelles de `@starterlib/ui/graphiques` (P08-07) : le catalogue par point d'entree (AD-10,
  * D154), comme ceux des donnees et de la navigation. La langue suit celle du dictionnaire du tronc.
@@ -76,6 +86,20 @@ export interface LibellesGraphiques {
    * variation depuis le premier point, deja formatees ; `null` : un seul point.
    */
   readonly tendance: (dernier: string, variation: string | null) => string;
+  /** L'en-tete de la colonne des effectifs du tableau equivalent de `st-histogram` (P08-18). */
+  readonly colonneEffectif: string;
+  /** Le nom de l'axe des effectifs de `st-histogram`, au-dessus de ses graduations. */
+  readonly axeEffectif: string;
+  /** Une classe dans le tableau equivalent : ses bornes, deja formatees (« 0 % a 5 % »). */
+  readonly intervalle: (debut: string, fin: string) => string;
+  /** Le nom de la liste des classes, lue par le lecteur d'ecran sous l'histogramme. */
+  readonly classes: string;
+  /** Une classe lue par le lecteur d'ecran : ses bornes et son effectif, deja formates. */
+  readonly classe: (debut: string, fin: string, effectif: string) => string;
+  /** La legende des classes negatives (hachurees) d'un histogramme. */
+  readonly classesNegatives: string;
+  /** La legende des classes positives ou nulles d'un histogramme. */
+  readonly classesPositives: string;
 }
 export declare const LIBELLES_GRAPHIQUES_FR: LibellesGraphiques;
 export declare const LIBELLES_GRAPHIQUES_EN: LibellesGraphiques;
@@ -181,7 +205,7 @@ interface MarqueurLu {
   readonly libelle: string;
 }
 /** Ce que le gabarit dessine : calcule une fois par changement des donnees ou de la largeur. */
-interface Dessin {
+interface Dessin$1 {
   readonly largeur: number;
   readonly hauteur: number;
   /** Le cadre du trace : de `gauche` a `droite`, de `haut` a `bas`. */
@@ -278,12 +302,11 @@ export declare class StLineChart {
   protected readonly marqueursLus: import("@angular/core").Signal<readonly MarqueurLu[]>;
   /** Aucun point lisible, ni dans les series ni dans le plafond. */
   protected readonly vide: import("@angular/core").Signal<boolean>;
-  protected readonly dessin: import("@angular/core").Signal<Dessin | null>;
+  protected readonly dessin: import("@angular/core").Signal<Dessin$1 | null>;
   /** Les colonnes du tableau equivalent : l'instant, chaque serie, le plafond. */
   protected readonly colonnes: import("@angular/core").Signal<readonly ColonneDeTableau[]>;
   /** Une ligne par instant, dans l'ordre du temps ; chaque valeur relue depuis sa chaine. */
   protected readonly lignes: import("@angular/core").Signal<readonly Readonly<Record<string, string>>[]>;
-  constructor();
   /** La courbe ou le tableau ; le bouton garde le focus, et la bascule s'annonce. */
   protected basculer(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<StLineChart, never>;
@@ -417,5 +440,178 @@ export declare class StSparkline {
     };
   }, {}, never, never, true, never>;
 }
+/** Une classe lue : ses bornes en nombres (l'echelle) et en chaines (l'affichage), son effectif. */
+interface ClasseLue {
+  readonly debut: number;
+  readonly fin: number;
+  readonly texteDebut: `${number}`;
+  readonly texteFin: `${number}`;
+  readonly effectif: number;
+}
+/**
+ * Les classes fournies, lisibles, dans l'ordre des bornes : une classe sans bornes decimales, sans
+ * etendue (`fin` <= `debut`) ou d'effectif qui n'est pas un entier positif ou nul est ecartee
+ * (signale en developpement).
+ */
+declare function lireClasses(classes: readonly ClasseDHistogramme[], source: string): ClasseLue[];
+/**
+ * Les classes de valeurs fournies (chaines decimales), en TypeScript pur : des bornes « agreables »
+ * (celles d'une graduation, `@starterlib/util/graduations`), environ `nombre` classes de meme
+ * largeur ; une valeur sur une borne va dans la classe qui commence a cette borne, et la derniere
+ * classe comprend sa fin. Aucun calcul statistique metier : le serveur qui en a besoin fournit ses
+ * classes.
+ */
+declare function classesDesValeurs(valeurs: readonly string[], nombre: number, source: string): ClasseLue[];
+/**
+ * Les graduations de l'axe des effectifs : de zero au plus grand, des pas ENTIERS (un effectif de
+ * deux ne se gradue pas par demis) ; tout vide, l'axe va de zero a un.
+ */
+declare function graduationsDEffectif(plusGrand: number, nombreVise: number): Graduations;
+/** Une classe a dessiner, et ce qui la dit. */
+interface ClasseDite extends ClasseLue {
+  readonly rang: number;
+  readonly negative: boolean;
+  readonly texteDuDebut: string;
+  readonly texteDeLaFin: string;
+  readonly texteDeLEffectif: string;
+}
+/** Ce que le gabarit dessine : calcule une fois par changement des donnees ou de la largeur. */
+interface Dessin {
+  readonly largeur: number;
+  readonly hauteur: number;
+  readonly gauche: number;
+  readonly droite: number;
+  readonly haut: number;
+  readonly bas: number;
+  readonly graduations: readonly {
+    readonly y: number;
+    readonly texte: string;
+  }[];
+  readonly reperes: readonly {
+    readonly x: number;
+    readonly texte: string;
+    readonly ancre: 'start' | 'middle' | 'end';
+  }[];
+  /** La verticale de zero, si l'axe passe de part et d'autre. */
+  readonly zero: number | null;
+  readonly barres: readonly {
+    readonly rang: number;
+    readonly negative: boolean;
+    readonly x: number;
+    readonly y: number;
+    readonly largeur: number;
+    readonly hauteur: number;
+  }[];
+}
+/**
+ * Une distribution par classes (P08-18, DEC-103) : resultats des essais du laboratoire, resultats
+ * publiables ; en SVG ecrit a la main, sans bibliotheque, au niveau d'accessibilite de la courbe.
+ *
+ * ```html
+ * <st-histogram etiquette="Rendements des essais" axe="Rendement" pourcentage
+ *   [resume]="resume()" [classes]="classes()" />
+ * <st-histogram etiquette="Durees des positions" axe="Duree, en jours" [valeurs]="durees()" />
+ * ```
+ *
+ * - **Classes fournies** (`classes`, de preference calculees par le serveur sur toutes ses donnees)
+ *   ou **calculees** en TypeScript pur sur des valeurs fournies (`valeurs`, `nombreDeClasses`) : des
+ *   bornes « agreables » de meme largeur. Aucun calcul statistique metier dans le composant.
+ * - **Accessible** : un `svg` `role="img"` nomme (`etiquette`) et decrit (`resume`, visible) ; la
+ *   liste des classes et de leurs effectifs se lit au lecteur d'ecran sous l'image ; « Voir les
+ *   donnees » bascule vers un `st-data-table` equivalent, au clavier, et la bascule s'annonce.
+ * - **La couleur ne dit rien seule** : une classe negative (sa fin au plus zero) est HACHUREE, ce que
+ *   le contraste force garde ; la verticale de zero est plus franche.
+ * - **Des chaines decimales** : les bornes affichees relisent leur chaine (regles-front §2), les
+ *   graduations viennent de `@starterlib/util/graduations` ; les effectifs se graduent par entiers.
+ * - **Sobre** : aucune animation ; 50 classes au plus, recommandees (signale en developpement).
+ */
+export declare class StHistogram {
+  private readonly locale;
+  protected readonly catalogue: import("@angular/core").Signal<import("@starterlib/ui").CatalogueDuPointDEntree<import("@starterlib/ui/graphiques").LibellesGraphiques>>;
+  protected readonly annonce: AnnonceLocale;
+  /** Les classes fournies ; prioritaires sur `valeurs` (les deux donnees : signale en developpement). */
+  readonly classes: import("@angular/core").InputSignal<readonly ClasseDHistogramme[] | null>;
+  /** Des valeurs en chaines decimales, rangees en classes par le composant. */
+  readonly valeurs: import("@angular/core").InputSignal<readonly string[] | null>;
+  /** Le nombre de classes vise pour des `valeurs` : les bornes agreables l'ajustent. */
+  readonly nombreDeClasses: import("@angular/core").InputSignal<number>;
+  /** Le nom de l'axe des valeurs, deja traduit (« Rendement de l'essai ») : sous l'axe et en tete du tableau. */
+  readonly axe: import("@angular/core").InputSignal<string>;
+  /** Code ISO 4217 : les bornes sont des montants dans cette devise. */
+  readonly devise: import("@angular/core").InputSignal<string | null>;
+  /** Sans devise : les bornes sont EN POUR CENT, telles que l'API les donne (3.25 : « 3,25 % »). */
+  readonly pourcentage: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le nom du graphique, deja traduit. */
+  readonly etiquette: import("@angular/core").InputSignal<string>;
+  /** Ce que la distribution montre, en une ou deux phrases, deja traduites : lu et affiche. */
+  readonly resume: import("@angular/core").InputSignal<string>;
+  /** La hauteur du trace, en pixels CSS. */
+  readonly hauteur: import("@angular/core").InputSignal<number>;
+  protected readonly vueDonnees: import("@angular/core").WritableSignal<boolean>;
+  private readonly largeur;
+  protected readonly identifiants: {
+    readonly motif: `${string}-motif`;
+    readonly resume: `${string}-resume`;
+  };
+  private readonly forme;
+  protected readonly classesDites: import("@angular/core").Signal<readonly ClasseDite[]>;
+  /** Des classes negatives ET positives : la legende dit la hachure. */
+  protected readonly deuxSignes: import("@angular/core").Signal<boolean>;
+  protected readonly dessin: import("@angular/core").Signal<Dessin | null>;
+  /** Les colonnes du tableau equivalent : la classe (nommee par l'axe), son effectif. */
+  protected readonly colonnes: import("@angular/core").Signal<readonly ColonneDeTableau[]>;
+  /** Une ligne par classe, classes vides comprises, dans l'ordre des bornes. */
+  protected readonly lignes: import("@angular/core").Signal<readonly Readonly<Record<string, string>>[]>;
+  /** L'histogramme ou le tableau ; le bouton garde le focus, et la bascule s'annonce. */
+  protected basculer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StHistogram, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StHistogram, "st-histogram", never, {
+    "classes": {
+      "alias": "classes";
+      "required": false;
+      "isSignal": true;
+    };
+    "valeurs": {
+      "alias": "valeurs";
+      "required": false;
+      "isSignal": true;
+    };
+    "nombreDeClasses": {
+      "alias": "nombreDeClasses";
+      "required": false;
+      "isSignal": true;
+    };
+    "axe": {
+      "alias": "axe";
+      "required": true;
+      "isSignal": true;
+    };
+    "devise": {
+      "alias": "devise";
+      "required": false;
+      "isSignal": true;
+    };
+    "pourcentage": {
+      "alias": "pourcentage";
+      "required": false;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": true;
+      "isSignal": true;
+    };
+    "resume": {
+      "alias": "resume";
+      "required": true;
+      "isSignal": true;
+    };
+    "hauteur": {
+      "alias": "hauteur";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 
 export {};

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

@@ -3470,6 +3470,19 @@ export declare class StFileUpload extends ContratDeChamp implements FormValueCon
   readonly nombreMax: import("@angular/core").InputSignal<number | null>;
   /** Texte du bouton de choix. `null` : « Choisir un fichier » ou « Choisir des fichiers ». */
   readonly libelleDuChoix: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Appareil photo natif (P08-17 d'Aplomb) : l'attribut `capture` du champ natif, `environment`
+   * (camera arriere : une piece, un document) ou `user` (camera avant). `null` (defaut) : aucun
+   * attribut, et le selecteur du systeme d'un telephone propose deja l'appareil photo des que
+   * `accept` admet des images.
+   *
+   * ⚠️ Le televersement reste toujours possible (SPEC-ONBOARDING 28) : les navigateurs de bureau
+   * ignorent l'attribut et ouvrent le selecteur de fichiers ; Safari sur iOS propose la photo, la
+   * phototheque et les fichiers ; Chrome sur Android ouvre directement l'appareil photo. Une page
+   * qui veut garder les fichiers sur Android offre un second champ sans `capture`. Aucune capture
+   * en direct ni detection de presence : la photo prise est un fichier comme un autre.
+   */
+  readonly capture: import("@angular/core").InputSignal<"environment" | "user" | null>;
   /**
    * Ou en est chaque fichier, par `cleDeFichier`. Le composant AFFICHE ce trajet,
    * il ne le fait pas : `StTeleversement` de `@starterlib/core` s'en charge.
@@ -3580,6 +3593,11 @@ export declare class StFileUpload extends ContratDeChamp implements FormValueCon
       "required": false;
       "isSignal": true;
     };
+    "capture": {
+      "alias": "capture";
+      "required": false;
+      "isSignal": true;
+    };
     "etats": {
       "alias": "etats";
       "required": false;

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

@@ -99,5 +99,216 @@ export declare class StVirtualList<T = unknown> {
     };
   }, {}, ["ligne"], never, true, never>;
 }
+/**
+ * Une colonne de `st-virtual-table`, decrite en donnees : la forme de `ColonneDeTableau` de
+ * `st-data-table` (`@starterlib/ui/listes`), qu'une application passe telle quelle. Ce point
+ * d'entree n'importe aucun autre point d'entree du socle : la forme est redite, pas importee.
+ */
+export interface ColonneVirtuelle {
+  readonly cle: string;
+  readonly libelle: string;
+  /** `fin` pour les nombres et les montants. */
+  readonly alignement?: 'debut' | 'fin';
+  /** Seulement si le SERVEUR trie sur cette colonne : le tableau emet `tri`, il ne reordonne rien. */
+  readonly triable?: boolean;
+  /** Libelle lu mais non affiche : colonne d'actions. Jamais vide. */
+  readonly libelleMasque?: boolean;
+}
+export type SensDeTriVirtuel = 'croissant' | 'decroissant';
+export interface TriVirtuel {
+  readonly cle: string;
+  readonly sens: SensDeTriVirtuel;
+}
+/** Contexte d'un gabarit de cellule : la ligne, sa colonne et son rang dans le tableau ENTIER. */
+export interface ContexteDeCelluleVirtuelle<T> {
+  readonly $implicit: T;
+  readonly colonne: ColonneVirtuelle;
+  readonly index: number;
+}
+/**
+ * Rendu d'une cellule de `st-virtual-table` : la meme ecriture que pour `st-data-table`, type par
+ * `[stCelluleDe]` :
+ *
+ * ```html
+ * <ng-template stCellule="montant" [stCelluleDe]="lignes()" let-ligne>
+ *   {{ ligne.montant }}
+ * </ng-template>
+ * ```
+ */
+export declare class StCelluleVirtuelle<T> {
+  readonly cle: import("@angular/core").InputSignal<string>;
+  /** Sert seulement au typage du contexte ; nom de l'attribut, d'ou l'absence d'alias. */
+  readonly stCelluleDe: import("@angular/core").InputSignal<readonly T[] | null | undefined>;
+  readonly gabarit: TemplateRef<ContexteDeCelluleVirtuelle<T>>;
+  static ngTemplateContextGuard<T>(_directive: StCelluleVirtuelle<T>, _contexte: unknown): _contexte is ContexteDeCelluleVirtuelle<T>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCelluleVirtuelle<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StCelluleVirtuelle<any>, "ng-template[stCellule]", never, {
+    "cle": {
+      "alias": "stCellule";
+      "required": true;
+      "isSignal": true;
+    };
+    "stCelluleDe": {
+      "alias": "stCelluleDe";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Le prochain sens d'un tri : non trie, croissant, decroissant, puis non trie (ou croissant). */
+export declare function prochainSensVirtuel(actuel: SensDeTriVirtuel | null, ternaire?: boolean): SensDeTriVirtuel | null;
+/**
+ * Tableau virtualise (P08-19 d'Aplomb ; lot 267, sous la condition ecrite de `README.md`) : des
+ * centaines de milliers de lignes AFFICHEES ensemble, dont seules celles de la fenetre (et une
+ * marge) existent dans le document, sur un `<table>` NATIF. A l'echelle seulement : au MVP,
+ * `st-data-table` et la pagination par curseur suffisent.
+ *
+ * ```html
+ * <st-virtual-table legende="Journal technique" [colonnes]="colonnes" [lignes]="lignes()" cle="id"
+ *   [(tri)]="tri">
+ *   <ng-template stCellule="niveau" [stCelluleDe]="lignes()" let-ligne>{{ ligne.niveau }}</ng-template>
+ * </st-virtual-table>
+ * ```
+ *
+ * - **Un tableau, pas une grille** : le lecteur d'ecran le parcourt de cellule en cellule. La
+ *   table porte `aria-rowcount` (lignes de donnees et ligne d'en-tete), chaque ligne rendue son
+ *   `aria-rowindex` dans le tableau ENTIER : « ligne 4 201 sur 100 001 » alors que trente lignes
+ *   seulement existent. Legende obligatoire (`caption`), colonne d'en-tete de ligne (la premiere
+ *   par defaut, `enTeteDeLigne`), en-tete fige en haut de la fenetre.
+ * - **Tri PILOTE** : un clic sur une colonne `triable` emet `tri` (croissant, decroissant, puis non
+ *   trie ; `triTernaire` a faux revient a croissant), porte par `aria-sort` ; le tableau ne
+ *   reordonne JAMAIS les lignes, le serveur le fait.
+ * - **Selection par cle** (`selectionnable`, `[(selection)]`, `cle`) : une case par ligne, nommee
+ *   par l'en-tete de sa ligne ; la colonne porte `libelleDeSelection`. Aucune selection globale :
+ *   sur cent mille lignes, elle appartient au serveur. Une SEULE case dans l'ordre de tabulation
+ *   (tabindex itinerant) : fleches haut et bas, Debut et Fin passent de case en case et amenent la
+ *   ligne dans la fenetre ; sans cela, Tab parcourait cent mille cases et ne sortait jamais du
+ *   tableau.
+ * - **Hauteur de ligne FIXE** (`hauteurDeLigne`, pixels CSS) : le calcul de la fenetre en depend ;
+ *   le texte qui deborde se tronque dans sa cellule. Fenetre focalisable et nommee par la legende,
+ *   qui defile aux fleches et a Page suivante ; hauteur `hauteurDeFenetre` (`24rem` par defaut).
+ */
+export declare class StVirtualTable<T = unknown> {
+  readonly legende: import("@angular/core").InputSignal<string>;
+  readonly colonnes: import("@angular/core").InputSignal<readonly ColonneVirtuelle[]>;
+  readonly lignes: import("@angular/core").InputSignal<readonly T[]>;
+  /** La propriete qui identifie une ligne : suivi du rendu et selection. */
+  readonly cle: import("@angular/core").InputSignal<keyof T & string>;
+  /** La colonne d'en-tete de ligne (`th scope="row"`) ; la premiere par defaut. */
+  readonly enTeteDeLigne: import("@angular/core").InputSignal<string | null>;
+  readonly hauteurDeLigne: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Hauteur de la fenetre, longueur CSS : `24rem` par defaut. */
+  readonly hauteurDeFenetre: import("@angular/core").InputSignal<string>;
+  readonly tri: import("@angular/core").ModelSignal<TriVirtuel | null>;
+  readonly triTernaire: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly selectionnable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly selection: import("@angular/core").ModelSignal<readonly string[]>;
+  /** Le nom, lu, de la colonne des cases (« Selection »), deja traduit. */
+  readonly libelleDeSelection: import("@angular/core").InputSignal<string>;
+  private readonly cellules;
+  private readonly fenetre;
+  protected readonly identifiant: string;
+  /** Decalage de l'en-tete fige : la fenetre deplace son contenu, l'en-tete revient en haut. */
+  protected readonly decalageDeLEnTete: import("@angular/core").WritableSignal<number>;
+  protected readonly hauteur: import("@angular/core").Signal<number>;
+  /** Marges de rendu : cinq lignes au moins de part et d'autre, dix au plus (60 lignes au plus). */
+  protected readonly margeMin: import("@angular/core").Signal<number>;
+  protected readonly margeMax: import("@angular/core").Signal<number>;
+  protected readonly colonneEnTete: import("@angular/core").Signal<string | null>;
+  protected readonly gabarits: import("@angular/core").Signal<Map<string, TemplateRef<ContexteDeCelluleVirtuelle<T>>>>;
+  private readonly choisies;
+  private readonly hote;
+  private readonly document;
+  /** La case active (tabindex itinerant) et la plage des lignes rendues. */
+  private readonly rangActif;
+  private readonly plageRendue;
+  /** La case dans l'ordre de tabulation : l'active si elle est rendue, sinon la premiere rendue. */
+  protected readonly rangTabulable: import("@angular/core").Signal<number>;
+  protected readonly suivi: (_rang: number, ligne: T) => unknown;
+  constructor();
+  protected cleDe(ligne: T): string;
+  /** La valeur brute d'une cellule sans gabarit : un texte, un nombre ou un booleen ; rien d'autre. */
+  protected valeur(ligne: T, colonne: ColonneVirtuelle): string;
+  protected identifiantDeLigne(rang: number): string;
+  protected triDe(colonne: ColonneVirtuelle): 'ascending' | 'descending' | 'none' | null;
+  protected trier(colonne: ColonneVirtuelle): void;
+  protected estChoisie(ligne: T): boolean;
+  protected basculer(ligne: T): void;
+  /** La case devient l'active quand elle recoit le focus (clic, Tab). */
+  protected activer(rang: number): void;
+  /** Fleches haut et bas, Debut et Fin : la case voisine, ou la premiere et la derniere. */
+  protected naviguer(evenement: KeyboardEvent, rang: number): void;
+  private caseDu;
+  /** Focalise la case d'un rang des qu'elle est rendue (quelques images apres un defilement). */
+  private focaliser;
+  /** Amene une ligne dans la fenetre (« aller a la ligne 42 000 »). */
+  allerA(rang: number, comportement?: ScrollBehavior): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StVirtualTable<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StVirtualTable<any>, "st-virtual-table", never, {
+    "legende": {
+      "alias": "legende";
+      "required": true;
+      "isSignal": true;
+    };
+    "colonnes": {
+      "alias": "colonnes";
+      "required": true;
+      "isSignal": true;
+    };
+    "lignes": {
+      "alias": "lignes";
+      "required": true;
+      "isSignal": true;
+    };
+    "cle": {
+      "alias": "cle";
+      "required": true;
+      "isSignal": true;
+    };
+    "enTeteDeLigne": {
+      "alias": "enTeteDeLigne";
+      "required": false;
+      "isSignal": true;
+    };
+    "hauteurDeLigne": {
+      "alias": "hauteurDeLigne";
+      "required": false;
+      "isSignal": true;
+    };
+    "hauteurDeFenetre": {
+      "alias": "hauteurDeFenetre";
+      "required": false;
+      "isSignal": true;
+    };
+    "tri": {
+      "alias": "tri";
+      "required": false;
+      "isSignal": true;
+    };
+    "triTernaire": {
+      "alias": "triTernaire";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionnable": {
+      "alias": "selectionnable";
+      "required": false;
+      "isSignal": true;
+    };
+    "selection": {
+      "alias": "selection";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleDeSelection": {
+      "alias": "libelleDeSelection";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "tri": "triChange";
+    "selection": "selectionChange";
+  }, ["cellules"], never, true, never>;
+}
 
 export {};