@sia-ui/react-web 0.7.1 → 0.8.0

package/dist/index.d.cts

@@ -1,58 +1,618 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode, Key, RefObject, ReactElement, HTMLAttributes, ImgHTMLAttributes, ButtonHTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, ForwardRefExoticComponent, RefAttributes, SVGProps, CSSProperties, PropsWithChildren } from 'react';
-import * as _sia_ui_headless from '@sia-ui/headless';
-import { PermissionRule, Placement, TableQuery, SliderValue, FormAdapter, FormValidator, FormSubmitResult, TableQueryStorage, TableQueryState, TableParamsMapping, SessionStore, SessionState, ToastPlacement, ToastId, ToastOptions } from '@sia-ui/headless';
-export { SliderValue, ToastId, ToastOptions, ToastPlacement, ToastTone, toast, toastStore } from '@sia-ui/headless';
+import { ReactNode, ImgHTMLAttributes, HTMLAttributes, RefObject, ReactElement, InputHTMLAttributes, ButtonHTMLAttributes, CSSProperties, Key, ForwardRefExoticComponent, RefAttributes, SVGAttributes, TextareaHTMLAttributes, SVGProps, PropsWithChildren } from 'react';
 import { ComponentTone, ComponentSize } from '@sia-ui/tokens';
+import * as _sia_ui_headless from '@sia-ui/headless';
+import { Placement, PermissionRule, TableQuery, ActivityLogMessages, SliderValue, AsyncFieldValidator, FormAdapter, FormValidator, FormSubmitResult, ResourceMessages, TableQueryStorage, TableQueryState, TableParamsMapping, CalendarEventInput, EventCalendarMessages, CalendarView, DayEvent, EventManagerMessages, SessionStore, SessionState, ToastPlacement, ToastId, ToastOptions } from '@sia-ui/headless';
+export { CalendarView, SliderValue, ToastId, ToastOptions, ToastPlacement, ToastTone, eventDays, toast, toastStore } from '@sia-ui/headless';
 import { Rule } from '@sia-ui/utils/validation';
 
-interface AccordionItem {
-    key: string;
+interface AccordionItem {
+    key: string;
+    title: ReactNode;
+    content: ReactNode;
+    /** Une ligne sous le titre, visible même replié. */
+    description?: ReactNode;
+    icon?: ReactNode;
+    /** À droite du titre : un compteur, un badge, un statut. */
+    meta?: ReactNode;
+    disabled?: boolean;
+}
+interface AccordionProps {
+    items: AccordionItem[];
+    /** `single` referme la section précédente, `multiple` les cumule. */
+    type?: "single" | "multiple";
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    /** En `single`, autorise à tout refermer. */
+    collapsible?: boolean;
+    variant?: "bordered" | "separated" | "plain";
+    className?: string;
+}
+/**
+ * Des sections dépliables.
+ *
+ * La hauteur s'anime sans être mesurée : le panneau est une grille dont la
+ * ligne passe de `0fr` à `1fr`. Pas de `scrollHeight`, pas de recalcul au
+ * redimensionnement, et un contenu qui change de taille suit tout seul.
+ */
+declare function Accordion({ items, type, value, defaultValue, onValueChange, collapsible, variant, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
+interface CollapseProps {
+    title: ReactNode;
+    children: ReactNode;
+    description?: ReactNode;
+    meta?: ReactNode;
+    icon?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    variant?: AccordionProps["variant"];
+    disabled?: boolean;
+    className?: string;
+}
+/** Une section seule. Le même rendu, pour le cas le plus courant. */
+declare function Collapse({ title, children, description, meta, icon, open, defaultOpen, onOpenChange, variant, disabled, className, }: CollapseProps): react_jsx_runtime.JSX.Element;
+
+type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";
+type AvatarShape = "circle" | "rounded" | "square";
+type AvatarVariant = "soft" | "solid" | "outline";
+/**
+ * La présence d'une personne.
+ *
+ * Quatre états et pas davantage : au-delà, la pastille devient un code que
+ * personne ne retient, et il faut une légende pour la lire.
+ */
+type AvatarStatus = "online" | "offline" | "busy" | "away";
+/**
+ * Les teintes dérivées du nom.
+ *
+ * Deux personnes aux mêmes initiales doivent se distinguer : dans une liste
+ * de participants, six pastilles identiques ne valent pas mieux qu'aucune.
+ * La couleur est donc déterministe — la même personne garde la sienne d'un
+ * écran à l'autre, d'une session à l'autre.
+ */
+declare const TEINTES: readonly ["primary", "info", "success", "warning", "danger", "secondary"];
+type AvatarTint = (typeof TEINTES)[number];
+declare function tintForName(name: string): AvatarTint;
+declare function initialsOf(name: string, count?: number): string;
+interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "children" | "width" | "height"> {
+    /** Le nom de la personne : il sert au repli, à la couleur et à l'annonce. */
+    name: string;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    variant?: AvatarVariant;
+    /** Force la teinte au lieu de la dériver du nom. */
+    tint?: AvatarTint;
+    /** Remplace les initiales — une icône, un emoji, deux lettres à soi. */
+    fallback?: ReactNode;
+    /** Nombre d'initiales quand le repli est automatique. */
+    initials?: 1 | 2;
+    status?: AvatarStatus;
+    /** Le libellé du statut, pour les lecteurs d'écran. Par défaut, celui de la locale. */
+    statusLabel?: string;
+    /** Un liseré qui détache l'avatar de son fond. */
+    ring?: boolean;
+    /** Rend l'avatar actionnable — un menu de compte, par exemple. */
+    onPress?: () => void;
+}
+/**
+ * Le portrait d'une personne, ou ce qui le remplace.
+ *
+ * Une image met du temps à arriver, échoue parfois, et manque souvent. Les
+ * trois cas sont traités sans que la mise en page bouge : l'espace est réservé
+ * d'emblée, le repli est peint dessous, et l'image se fond par-dessus quand
+ * elle arrive.
+ */
+declare function Avatar({ name, size, shape, variant, tint, fallback, initials, status, statusLabel, ring, onPress, className, src, alt, onError, onLoad, style, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    /**
+     * Au-delà, les suivants sont résumés par un compteur.
+     *
+     * Sans limite, une réunion de quarante personnes déborde de sa ligne et
+     * n'apprend plus rien : au-delà de cinq visages, on ne lit plus des gens,
+     * on lit une foule.
+     */
+    max?: number;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    variant?: AvatarVariant;
+    /** Le chevauchement, de 0 (côte à côte) à 1 (fortement empilés). */
+    overlap?: number;
+    /** Écarte les avatars au survol, pour les distinguer. */
+    spreadOnHover?: boolean;
+    /** Ce qu'affiche le compteur. Par défaut `+N`. */
+    renderOverflow?: (count: number) => ReactNode;
+}
+/**
+ * Plusieurs personnes, sur une ligne.
+ *
+ * Les avatars se chevauchent — c'est ce qui dit « un groupe » plutôt qu'« une
+ * liste ». Chacun porte un liseré de la couleur du fond, sans quoi la pile
+ * devient une bouillie dès que deux teintes se ressemblent.
+ */
+declare function AvatarGroup({ children, max, size, shape, variant, overlap, spreadOnHover, renderOverflow, className, style, ...props }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    label?: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    variant?: "dots" | "ring" | "double-ring";
+    tone?: ComponentTone | "current";
+}
+/**
+ * Une attente sans durée connue.
+ *
+ * Quand la durée est connue, une barre de progression en dit plus. Le ton
+ * `current` reprend la couleur du texte environnant : un indicateur posé
+ * dans un bouton doit suivre la couleur du bouton, pas celle du thème.
+ */
+declare function Spinner({ label: labelProp, size: sizeProp, variant: variantProp, tone: toneProp, className, ...props }: SpinnerProps): react_jsx_runtime.JSX.Element;
+
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: ComponentTone;
+    variant?: "soft" | "solid" | "outline";
+    left?: ReactNode;
+    right?: ReactNode;
+    loading?: boolean;
+    loadingLabel?: string;
+    spinnerProps?: Omit<SpinnerProps, "label">;
+}
+/**
+ * Une étiquette d'état, courte et dense.
+ *
+ * Elle porte un ton, jamais une action : un badge cliquable se confond avec
+ * un bouton petit, et l'on découvre qu'il ne l'était pas en cliquant. Ce
+ * qui agit est un bouton.
+ */
+declare function Badge({ tone: toneProp, variant: variantProp, left, right, loading, loadingLabel: loadingLabelProp, spinnerProps, className, children, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+/**
+ * Le ton d'une valeur, lu dans une table de correspondance.
+ *
+ * Un statut, une action de journal, un environnement : chaque écran tenait
+ * sa propre table et sa propre fonction pour la lire. Celle-ci est la seule.
+ *
+ * ```ts
+ * const TONS = { payee: "success", attente: "warning", annulee: "danger" };
+ * toneOf(TONS, facture.statut); // "success" | … | "neutral"
+ * ```
+ */
+declare function toneOf(tones: Readonly<Record<string, ComponentTone>> | undefined, value: unknown, fallback?: ComponentTone): ComponentTone;
+interface StatusBadgeProps extends Omit<BadgeProps, "tone" | "children"> {
+    /** La valeur brute : `"payee"`, `"prod"`, `"delete"`. */
+    value: string | number | null | undefined;
+    /** Le ton de chaque valeur. */
+    tones?: Readonly<Record<string, ComponentTone>>;
+    /** Le libellé de chaque valeur. À défaut, la valeur elle-même. */
+    labels?: Readonly<Record<string, ReactNode>>;
+    /** Le ton d'une valeur absente de `tones`. `neutral` par défaut. */
+    fallbackTone?: ComponentTone;
+    /** Ce qui s'affiche sans valeur. Rien par défaut. */
+    empty?: ReactNode;
+}
+/**
+ * Une valeur rendue en pastille, ton et libellé tirés de deux tables.
+ *
+ * Déclarées une fois par domaine — les statuts de facture, les actions du
+ * journal — puis passées partout où la valeur s'affiche : colonne libre,
+ * détail, carte. Une valeur inconnue garde une pastille neutre plutôt que de
+ * disparaître.
+ */
+declare function StatusBadge({ value, tones, labels, fallbackTone, empty, ...props }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Les douze placements du moteur de géométrie.
+ *
+ * Ce composant n'en exposait que quatre — haut et bas — parce qu'il calculait
+ * lui-même sa position, en vertical seulement. Le calcul vit dans
+ * `@sia-ui/headless`, sait basculer et recadrer dans les deux axes, et sert
+ * déjà le natif : le refaire ici privait tous les flottants des côtés.
+ */
+type OverlayPlacement = Placement;
+interface OverlayProps {
+    open: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    placement?: OverlayPlacement;
+    offset?: number;
+    matchAnchorWidth?: boolean;
+    viewportPadding?: number;
+    className?: string;
+    id?: string;
+    role?: string;
+}
+/**
+ * Ce qui flotte à côté d'un élément.
+ *
+ * Le socle des menus, des listes déroulantes et des infobulles. Il place le
+ * panneau parmi douze positions, le retourne quand le bord de la fenêtre
+ * approche, et le ramène dans la vue plutôt que de le laisser déborder.
+ *
+ * Le calcul vit dans `@sia-ui/headless` : il ne dépend d'aucun rendu, et
+ * sert donc aussi à ce qui n'est pas le DOM.
+ */
+declare function Overlay({ open, anchorRef, onOpenChange, children, placement, offset, matchAnchorWidth, viewportPadding, className, ...props }: OverlayProps): react.ReactPortal | null;
+
+interface MenuItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Un raccourci affiché à droite. Purement indicatif : rien n'est écouté. */
+    shortcut?: string;
+    disabled?: boolean;
+    danger?: boolean;
+    /** Affiche une coche. `undefined` : l'entrée n'est pas cochable. */
+    checked?: boolean;
+    description?: ReactNode;
+    onSelect?: () => void;
+}
+interface MenuSeparator {
+    key: string;
+    type: "separator";
+}
+interface MenuLabel {
+    key: string;
+    type: "label";
+    label: ReactNode;
+}
+/**
+ * Un en-tête à contenu libre : le profil d'un menu de compte, un résumé.
+ *
+ * `label` est un titre de section — petit, en capitales, sur une ligne — et
+ * n'a pas vocation à porter un avatar, un nom, une adresse et un rôle.
+ * L'en-tête ne se sélectionne pas et le clavier le saute.
+ */
+interface MenuHeader {
+    key: string;
+    type: "header";
+    content: ReactNode;
+}
+type MenuEntry = MenuItem | MenuSeparator | MenuLabel | MenuHeader;
+/** Ce qu'on règle de l'`Overlay` d'un menu : tout sauf ce que le menu pilote. */
+type MenuOverlayProps = Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
+interface MenuListProps {
+    items: MenuEntry[];
+    onSelect: (item: MenuItem) => void;
+    onClose: () => void;
+    /** Index actif, piloté par le parent pour que le clavier suive. */
+    activeIndex: number;
+    onActiveIndexChange: (index: number) => void;
+    id?: string | undefined;
+    className?: string | undefined;
+}
+/**
+ * Le panneau seul, sans déclencheur.
+ *
+ * Extrait parce que `DropdownMenu` et `ContextMenu` n'ont en commun que lui :
+ * tout le reste — l'ancrage, le geste d'ouverture — diffère.
+ */
+declare function MenuList({ items, onSelect, onClose, activeIndex, onActiveIndexChange, id, className, }: MenuListProps): react_jsx_runtime.JSX.Element;
+interface DropdownMenuProps {
+    items: MenuEntry[];
+    children: ReactElement<{
+        onClick?: () => void;
+        "aria-expanded"?: boolean;
+    }>;
+    onSelect?: (item: MenuItem) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: OverlayPlacement;
+    matchTriggerWidth?: boolean;
+    /** Le positionnement du panneau : décalage, marge au bord de l'écran, id. */
+    overlayProps?: MenuOverlayProps;
+    className?: string;
+}
+/**
+ * Un menu accroché à un bouton.
+ *
+ * Il repose sur `Overlay` : le repositionnement quand la place manque en bas,
+ * la fermeture au clic extérieur et à Échap sont déjà là et ne sont pas
+ * réécrites ici.
+ */
+declare function DropdownMenu({ items, children, onSelect, open: openProp, defaultOpen, onOpenChange, placement, matchTriggerWidth, overlayProps, className, }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
+interface ContextMenuProps {
+    items: MenuEntry[];
+    children: ReactNode;
+    onSelect?: (item: MenuItem) => void;
+    /** Le positionnement du panneau, comme pour `DropdownMenu`. */
+    overlayProps?: MenuOverlayProps;
+    className?: string;
+}
+/**
+ * Le même menu, ouvert au clic droit sur une zone.
+ *
+ * L'ancre est un point, pas un élément : un repère de taille nulle est posé
+ * aux coordonnées du pointeur et confié à `Overlay`, qui ne voit pas la
+ * différence. C'est ce qui évite un second moteur de placement.
+ */
+declare function ContextMenu({ items, children, onSelect, overlayProps, className, }: ContextMenuProps): react_jsx_runtime.JSX.Element;
+
+interface AccountMenuProps {
+    /** Le nom de la personne connectée : avatar, en-tête et libellé du bouton. */
+    name: string;
+    email?: ReactNode;
+    /** Le rôle, en pastille sous le nom : « Administrateur ». */
+    role?: ReactNode;
+    /** La photo. À défaut, les initiales de `name`. */
+    avatarSrc?: string;
+    /** Les entrées sous l'en-tête : profil, préférences, déconnexion. */
+    items: MenuEntry[];
+    onSelect?: (item: MenuItem) => void;
+    /** Le nom accessible du déclencheur. Par défaut, celui de la locale, `accountMenu.trigger` (« Compte de {name} »). */
+    triggerLabel?: string;
+    /** L'avatar du déclencheur — taille, forme, variante. */
+    avatarProps?: Partial<Omit<AvatarProps, "name">>;
+    /** L'avatar de l'en-tête du menu. */
+    headerAvatarProps?: Partial<Omit<AvatarProps, "name">>;
+    /** La pastille du rôle — ton, variante. */
+    roleBadgeProps?: Partial<Omit<BadgeProps, "children">>;
+    /** Le menu lui-même, hors entrées et déclencheur qu'il reçoit d'ici. */
+    dropdownMenuProps?: Partial<Omit<DropdownMenuProps, "items" | "children" | "onSelect">>;
+    className?: string;
+}
+/**
+ * Le menu du compte connecté : un avatar qui ouvre un menu à en-tête de profil.
+ *
+ * Chaque application le recomposait — avatar dans un bouton qui lui
+ * ajoutait un cadre, en-tête forcé dans un titre de section en capitales.
+ * Ici, le déclencheur est l'avatar seul, rond et sans fond, et l'en-tête une
+ * entrée `header` à contenu libre du `DropdownMenu`.
+ */
+declare function AccountMenu({ name, email, role, avatarSrc, items, onSelect, triggerLabel, avatarProps, headerAvatarProps, roleBadgeProps, dropdownMenuProps, className, }: AccountMenuProps): react_jsx_runtime.JSX.Element;
+
+interface SearchInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Appelé à la validation, et après le délai si `searchDelay` est posé. */
+    onSearch?: (value: string) => void;
+    /**
+     * Millisecondes d'inactivité avant de déclencher `onSearch`.
+     *
+     * `0` — le défaut — ne déclenche qu'à la validation. Au-delà, la recherche
+     * part quand la frappe s'arrête : c'est ce que chaque projet réécrivait
+     * autour de ce champ.
+     */
+    searchDelay?: number;
+    clearable?: boolean;
+    /** Le nom du champ. Par défaut, `search` de la locale. */
+    searchLabel?: string;
+    /** Le bouton qui vide le champ. Par défaut, `searchInput.clear` de la locale. */
+    clearLabel?: string;
+}
+/**
+ * Une recherche, avec son délai.
+ *
+ * `searchDelay` vaut zéro par défaut : la recherche ne part qu'à la
+ * validation. C'est le réglage sûr — une requête à chaque frappe se paie en
+ * appels serveur, et le défaut ne doit pas engager ce coût sans qu'on l'ait
+ * demandé.
+ */
+declare const SearchInput: react.ForwardRefExoticComponent<SearchInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface EmptyStateProps {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    compact?: boolean;
+    className?: string;
+}
+/**
+ * Ce qu'on montre quand il n'y a rien.
+ *
+ * Une liste vide sans explication ressemble à un chargement bloqué. Elle
+ * porte donc une action : le vide initial est le meilleur moment pour
+ * proposer de créer le premier élément.
+ */
+declare function EmptyState({ icon, title, description, action, compact, className }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+type TooltipVariant = "solid" | "outline";
+interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, "content"> {
+    content?: ReactNode;
+    children: ReactNode;
+    tone?: ComponentTone;
+    /** Seules `sm`, `md` et `lg` sont dessinées — voir `styles.css`. */
+    size?: ComponentSize;
+    placement?: Placement;
+    variant?: TooltipVariant;
+    /** Délai avant apparition, en millisecondes. */
+    delay?: number;
+    disabled?: boolean;
+}
+/** Alias historique, conservé pour les composants venus du registre. */
+type ITooltipProps = TooltipProps;
+type ITooltipVariant = TooltipVariant;
+/**
+ * Bulle d'aide positionnée hors du flux.
+ *
+ * Le contenu passe par un portail plutôt que par un `position: absolute` dans
+ * le flux : un tooltip posé dans une `Card` ou une cellule de `DataTable` —
+ * toutes deux en `overflow: hidden` — serait sinon rogné.
+ */
+declare function Tooltip({ content, children, placement, variant, tone, size, delay, disabled, className, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: "solid" | "outline" | "ghost";
+    /**
+     * Le ton sémantique de l'action.
+     *
+     * `.sia-button--danger` existait dans la feuille de style sans qu'aucune
+     * prop ne permette de l'atteindre : une action de suppression ne pouvait pas
+     * être rouge sans `className` manuel.
+     */
+    tone?: ComponentTone;
+    size?: "sm" | "md" | "lg";
+    radius?: "default" | "none" | "sm" | "lg" | "full";
+    loading?: boolean;
+    loadingLabel?: string;
+    spinnerProps?: Omit<SpinnerProps, "label">;
+    tooltip?: Omit<TooltipProps, "children">;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+}
+/**
+ * L'action, sous toutes ses formes.
+ *
+ * Le chargement y est un état et non un remplacement : le bouton garde sa
+ * taille et son libellé pendant l'appel. Un bouton qui devient un rond
+ * tournant fait bouger la mise en page, et le clic suivant tombe à côté.
+ */
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ErrorStateProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    error?: unknown;
+    action?: ReactNode;
+    onRetry?: () => void;
+    retryLabel?: string;
+    compact?: boolean;
+    className?: string;
+    /**
+     * Les props du bouton « Réessayer » — variante, taille, icône. Sans
+     * `onClick`, branché sur `onRetry`, ni `children` : le libellé passe par
+     * `retryLabel`.
+     */
+    retryButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+}
+/**
+ * Un échec, et de quoi en sortir.
+ *
+ * `error` accepte n'importe quoi : une `Error`, une réponse HTTP, une
+ * chaîne. Ce qui arrive d'un appel réseau n'a pas de forme garantie, et
+ * exiger un type ferait écrire un `try` autour de chaque affichage
+ * d'erreur.
+ */
+declare function ErrorState({ title: titleProp, description, error, action, onRetry, retryLabel: retryLabelProp, compact, className, retryButtonProps }: ErrorStateProps): react_jsx_runtime.JSX.Element;
+
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    width?: CSSProperties["width"];
+    height?: CSSProperties["height"];
+    radius?: CSSProperties["borderRadius"];
+    circle?: boolean;
+}
+/**
+ * La forme de ce qui n'est pas encore là.
+ *
+ * Aux dimensions du contenu attendu, et non d'une taille générique : c'est
+ * ce qui évite le sursaut de mise en page à l'arrivée des données, lequel
+ * fait cliquer à côté.
+ */
+declare function Skeleton({ className, width, height, radius, circle, style, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+type CheckboxValue = string | number;
+interface CheckboxGroupProps {
+    value?: CheckboxValue[];
+    defaultValue?: CheckboxValue[];
+    onValueChange?: (value: CheckboxValue[]) => void;
+    disabled?: boolean;
+    variant?: "default" | "button";
+    orientation?: "horizontal" | "vertical";
+    size?: "sm" | "md" | "lg";
+    tone?: ComponentTone;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * Une case, ou un groupe de cases.
+ *
+ * `CheckboxGroup` gère la liste des valeurs cochées; la case seule gère la
+ * sienne. L'état indéterminé est une troisième valeur, pas un entre-deux
+ * visuel : il dit « certains enfants sont cochés », ce qu'aucun booléen ne
+ * sait exprimer.
+ */
+declare function CheckboxGroup({ value, defaultValue, onValueChange, disabled, variant, orientation, size, tone, className, children, }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "size"> {
+    value?: CheckboxValue;
+    label?: ReactNode;
+    children?: ReactNode;
+    description?: ReactNode;
+    indeterminate?: boolean;
+    onValueChange?: (checked: boolean) => void;
+    size?: "sm" | "md" | "lg";
+    tone?: ComponentTone;
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    label: string;
+    icon: ReactNode;
+    variant?: "solid" | "outline" | "ghost";
+    size?: "sm" | "md" | "lg";
+    radius?: "default" | "none" | "sm" | "lg" | "full";
+    tooltip?: Omit<TooltipProps, "children">;
+}
+/**
+ * Une action réduite à son icône.
+ *
+ * `label` est obligatoire : une icône seule n'a pas de nom, et un lecteur
+ * d'écran annoncerait « bouton » sans dire lequel. Le libellé sert aussi
+ * d'infobulle — ce que l'icône signifie doit rester atteignable à la
+ * souris comme au clavier.
+ */
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
     title: ReactNode;
-    content: ReactNode;
-    /** Une ligne sous le titre, visible même replié. */
     description?: ReactNode;
-    icon?: ReactNode;
-    /** À droite du titre : un compteur, un badge, un statut. */
-    meta?: ReactNode;
-    disabled?: boolean;
-}
-interface AccordionProps {
-    items: AccordionItem[];
-    /** `single` referme la section précédente, `multiple` les cumule. */
-    type?: "single" | "multiple";
-    value?: string[];
-    defaultValue?: string[];
-    onValueChange?: (value: string[]) => void;
-    /** En `single`, autorise à tout refermer. */
-    collapsible?: boolean;
-    variant?: "bordered" | "separated" | "plain";
+    children?: ReactNode;
+    footer?: ReactNode;
+    closeOnBackdrop?: boolean;
+    closeLabel?: string;
     className?: string;
 }
 /**
- * Des sections dépliables.
+ * Une boîte qui interrompt.
  *
- * La hauteur s'anime sans être mesurée : le panneau est une grille dont la
- * ligne passe de `0fr` à `1fr`. Pas de `scrollHeight`, pas de recalcul au
- * redimensionnement, et un contenu qui change de taille suit tout seul.
+ * Elle enferme le focus et bloque le défilement de la page : sans cela, la
+ * tabulation continue derrière le voile, et l'on remplit un formulaire
+ * qu'on ne voit pas. L'échappement la referme toujours — c'est la sortie
+ * que tout le monde essaie en premier.
  */
-declare function Accordion({ items, type, value, defaultValue, onValueChange, collapsible, variant, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
-interface CollapseProps {
+declare function Modal({ open, onOpenChange, title, description, children, footer, closeOnBackdrop, closeLabel: closeLabelProp, className }: ModalProps): react.ReactPortal | null;
+
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
     title: ReactNode;
-    children: ReactNode;
     description?: ReactNode;
-    meta?: ReactNode;
-    icon?: ReactNode;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    variant?: AccordionProps["variant"];
-    disabled?: boolean;
-    className?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    tone?: Extract<ComponentTone, "primary" | "danger">;
+    loading?: boolean;
+    onConfirm: () => void | Promise<void>;
+    /**
+     * Les props de la `Modal`. Sans `open`, `onOpenChange`, `children` ni
+     * `footer`, que la boîte de confirmation tient elle-même. Pendant
+     * `loading`, un clic sur le voile ne ferme jamais, quel que soit
+     * `closeOnBackdrop` : ce serait abandonner un appel encore en vol.
+     */
+    modalProps?: Partial<Omit<ModalProps, "open" | "onOpenChange" | "children" | "footer">>;
+    /**
+     * Les props du bouton de confirmation. Sans `onClick` ni `loading`,
+     * branchés sur `onConfirm` et `loading` ; le libellé passe par
+     * `confirmLabel`.
+     */
+    confirmButtonProps?: Partial<Omit<ButtonProps, "onClick" | "loading" | "children">>;
+    /**
+     * Les props du bouton d'annulation. Sans `onClick`, qui referme la boîte ;
+     * `disabled` s'ajoute à `loading` au lieu de le remplacer.
+     */
+    cancelButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
 }
-/** Une section seule. Le même rendu, pour le cas le plus courant. */
-declare function Collapse({ title, children, description, meta, icon, open, defaultOpen, onOpenChange, variant, disabled, className, }: CollapseProps): react_jsx_runtime.JSX.Element;
+/**
+ * La question qu'on pose avant de détruire.
+ *
+ * `onConfirm` peut rendre une promesse : le bouton reste occupé tant qu'elle
+ * n'a pas abouti. Sans cela, la boîte se referme sur un appel encore en
+ * vol, et l'on ignore si la suppression a eu lieu.
+ */
+declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel: confirmLabelProp, cancelLabel: cancelLabelProp, tone, loading, onConfirm, modalProps, confirmButtonProps, cancelButtonProps }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
 
 /** Liste dense, ou grille de cartes. */
 type DataTableView = "table" | "cards";
@@ -145,6 +705,13 @@ interface DataTableProps<T> {
      * lettre ; Entrée et l'effacement déclenchent sans attendre.
      */
     searchDelay?: number;
+    /**
+     * Le champ de recherche : placeholder, libellés, `clearable`, classe.
+     *
+     * La valeur et les rappels restent au tableau — c'est lui qui filtre et
+     * qui temporise ; les déléguer ici ferait deux recherches concurrentes.
+     */
+    searchInputProps?: Partial<Omit<SearchInputProps, "value" | "defaultValue" | "onValueChange" | "onSearch" | "searchDelay">>;
     layout?: "auto" | "fixed";
     /** Hauteur du corps. Sans elle, `stickyHeader` n'a rien où se coller. */
     maxHeight?: string;
@@ -159,6 +726,32 @@ interface DataTableProps<T> {
     actionsHeader?: ReactNode;
     /** `icon` garde la colonne étroite sur un tableau déjà large. */
     actionsDisplay?: "icon" | "label";
+    /**
+     * Les boutons d'action à libellé : variante, taille, classe.
+     *
+     * Le clic, le libellé et l'état désactivé viennent de chaque `RowAction`.
+     */
+    rowActionButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children" | "disabled">>;
+    /**
+     * Les boutons d'action réduits à l'icône, déclencheur du menu « autres
+     * actions » compris. Une `tooltip` passée ici se fusionne avec celle de
+     * l'action, qui garde son libellé.
+     */
+    rowActionIconButtonProps?: Partial<Omit<IconButtonProps, "onClick" | "label" | "icon" | "disabled">>;
+    /**
+     * Le menu des actions qui ne tiennent pas en ligne : placement, décalage.
+     *
+     * Ni `open` ni `defaultOpen` : partagés par toutes les lignes, ils
+     * ouvriraient tous les menus à la fois.
+     */
+    rowActionsMenuProps?: Partial<Omit<DropdownMenuProps, "items" | "children" | "onSelect" | "open" | "defaultOpen">>;
+    /**
+     * La confirmation d'une action : libellés par défaut, `loading`.
+     *
+     * Ce que déclare `confirm` sur l'action l'emporte ; le ton suit
+     * `confirm.destructive`, l'ouverture et la validation restent au tableau.
+     */
+    confirmDialogProps?: Partial<Omit<ConfirmDialogProps, "open" | "onOpenChange" | "onConfirm" | "title" | "tone">>;
     /** Évalue les règles de permission des actions. */
     can?: (rule: PermissionRule) => boolean;
     view?: DataTableView;
@@ -176,13 +769,28 @@ interface DataTableProps<T> {
     loading?: boolean;
     /** Lignes fantômes pendant le premier chargement. */
     skeletonRows?: number;
+    /** Les blocs fantômes : rayon, classe, style. Leurs tailles ne sont que des défauts. */
+    skeletonProps?: Partial<SkeletonProps>;
     error?: ReactNode;
     onRetry?: () => void;
+    /**
+     * L'état d'erreur : titre, libellé du bouton, action, `compact`.
+     *
+     * Le message vient de `error` ; `onRetry` du tableau l'emporte s'il est
+     * fourni.
+     */
+    errorStateProps?: Partial<Omit<ErrorStateProps, "description" | "error">>;
     empty?: {
         title?: ReactNode;
         description?: ReactNode;
         action?: ReactNode;
+        icon?: ReactNode;
     };
+    /**
+     * L'état vide au complet : icône, `compact`, classe. Ce que déclare `empty`
+     * l'emporte sur les mêmes clés.
+     */
+    emptyStateProps?: Partial<EmptyStateProps>;
     /**
      * Ajoute une colonne de cases à cocher.
      *
@@ -195,6 +803,13 @@ interface DataTableProps<T> {
     defaultSelectedKeys?: Key[];
     onSelectionChange?: (keys: Key[], rows: T[]) => void;
     isRowSelectable?: (row: T, index: number) => boolean;
+    /**
+     * Les cases de sélection, en-tête comprise : taille, ton, classe.
+     *
+     * L'état coché, l'indétermination et le rappel sont calculés par le
+     * tableau ; le clic reste retenu pour ne pas déclencher `onRowClick`.
+     */
+    checkboxProps?: Partial<Omit<CheckboxProps, "checked" | "defaultChecked" | "indeterminate" | "onValueChange" | "onChange" | "onClick" | "disabled" | "value">>;
     /** Barre affichée dès qu'une ligne est cochée. */
     selectionActions?: (context: {
         keys: Key[];
@@ -212,39 +827,53 @@ interface DataTableProps<T> {
     className?: string;
 }
 
+interface FiltersBarProps {
+    search?: ReactNode;
+    filters?: ReactNode;
+    actions?: ReactNode;
+    activeCount?: number;
+    onReset?: () => void;
+    resetLabel?: string;
+    /**
+     * La largeur de chaque filtre — `12rem` par défaut. Les filtres se placent
+     * côte à côte à cette largeur, et passent à la ligne quand elle manque.
+     */
+    filterWidth?: string;
+    className?: string;
+}
 /**
- * Les douze placements du moteur de géométrie.
+ * La barre au-dessus d'une liste : recherche, filtres, actions.
  *
- * Ce composant n'en exposait que quatre — haut et bas — parce qu'il calculait
- * lui-même sa position, en vertical seulement. Le calcul vit dans
- * `@sia-ui/headless`, sait basculer et recadrer dans les deux axes, et sert
- * déjà le natif : le refaire ici privait tous les flottants des côtés.
+ * `activeCount` affiche combien de filtres sont en vigueur. Sans ce compte,
+ * une liste filtrée ressemble à une liste vide, et l'on cherche la panne
+ * avant de penser au filtre posé la veille.
  */
-type OverlayPlacement = Placement;
-interface OverlayProps {
-    open: boolean;
-    anchorRef: RefObject<HTMLElement | null>;
-    onOpenChange: (open: boolean) => void;
-    children: ReactNode;
-    placement?: OverlayPlacement;
-    offset?: number;
-    matchAnchorWidth?: boolean;
-    viewportPadding?: number;
+declare function FiltersBar({ search, filters, actions, activeCount, onReset, resetLabel: resetLabelProp, filterWidth, className }: FiltersBarProps): react_jsx_runtime.JSX.Element;
+
+interface PageHeaderProps {
+    title: ReactNode;
+    description?: ReactNode;
+    eyebrow?: ReactNode;
+    actions?: ReactNode;
+    /**
+     * Le niveau du titre. `1` — le défaut — pour l'en-tête d'un écran.
+     *
+     * `2` ou `3` pour une section dans un écran qui a déjà son `<h1>` : la
+     * liste des environnements dans la fiche d'un projet. Le titre y est plus
+     * petit et l'espace sous l'en-tête plus court.
+     */
+    level?: 1 | 2 | 3;
     className?: string;
-    id?: string;
-    role?: string;
 }
 /**
- * Ce qui flotte à côté d'un élément.
- *
- * Le socle des menus, des listes déroulantes et des infobulles. Il place le
- * panneau parmi douze positions, le retourne quand le bord de la fenêtre
- * approche, et le ramène dans la vue plutôt que de le laisser déborder.
+ * Le titre d'un écran, et ses actions.
  *
- * Le calcul vit dans `@sia-ui/headless` : il ne dépend d'aucun rendu, et
- * sert donc aussi à ce qui n'est pas le DOM.
+ * Un seul `<h1>` par page, rendu ici : la hiérarchie des titres est ce qui
+ * permet de parcourir un écran au lecteur d'écran, et deux `<h1>` la
+ * cassent sans que rien ne se voie. Une section imbriquée passe donc
+ * `level={2}`.
  */
-declare function Overlay({ open, anchorRef, onOpenChange, children, placement, offset, matchAnchorWidth, viewportPadding, className, ...props }: OverlayProps): react.ReactPortal | null;
+declare function PageHeader({ title, description, eyebrow, actions, level, className, }: PageHeaderProps): react_jsx_runtime.JSX.Element;
 
 interface SelectOption {
     value: string;
@@ -262,13 +891,18 @@ interface SelectProps {
     value?: string;
     defaultValue?: string;
     onValueChange?: (value: string, option?: SelectOption) => void;
+    /** Le texte du champ vide. Par défaut, `select` de la locale. */
     placeholder?: string;
     searchable?: boolean;
+    /** Le texte indicatif de la recherche. Par défaut, `searchPlaceholder` de la locale. */
     searchPlaceholder?: string;
     fetcher?: (query: string, signal?: AbortSignal) => Promise<SelectOption[]>;
     debounce?: number;
+    /** Pendant le chargement distant. Par défaut, `selectField.loadingOptions` de la locale. */
     loadingText?: ReactNode;
+    /** Quand rien ne correspond. Par défaut, `noResults` de la locale. */
     emptyText?: ReactNode;
+    /** Quand le chargement échoue. Par défaut, `selectField.loadError` de la locale. */
     errorText?: ReactNode;
     clearable?: boolean;
     disabled?: boolean;
@@ -276,37 +910,110 @@ interface SelectProps {
     required?: boolean;
     placement?: OverlayPlacement;
     /**
-     * Ce que montre le déclencheur. Par défaut, le libellé de l'option.
-     *
-     * La liste garde ses libellés complets — « 🇨🇲 Cameroun (+237) » — pendant
-     * que le champ fermé n'affiche que ce qui tient : « 🇨🇲 +237 ».
+     * Réglages du panneau de la liste — décalage, marge au bord, classe.
+     * `matchAnchorWidth: false` le laisse prendre la largeur de ses options.
+     */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
+    /** Réglages de l'indicateur de chargement des options distantes. */
+    spinnerProps?: Partial<SpinnerProps>;
+    /**
+     * Ce que montre le déclencheur. Par défaut, le libellé de l'option.
+     *
+     * La liste garde ses libellés complets — « 🇨🇲 Cameroun (+237) » — pendant
+     * que le champ fermé n'affiche que ce qui tient : « 🇨🇲 +237 ».
+     */
+    renderValue?: (option: SelectOption | undefined) => ReactNode;
+    /**
+     * `embedded` retire bordure, fond et largeur pleine du déclencheur : le
+     * `Select` se loge alors dans un autre contrôle — l'indicatif d'un
+     * `PhoneInput`, la taille de page d'une `Pagination`.
+     */
+    variant?: "default" | "embedded";
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+/**
+ * Un choix parmi une liste.
+ *
+ * Le champ n'est pas un `<select>` natif : celui-ci ne sait ni chercher, ni
+ * afficher une description sous chaque option, ni charger ses choix à la
+ * demande. Le comportement clavier du natif, lui, est reproduit — flèches,
+ * première lettre, échappement.
+ *
+ * `fetcher` sert les listes qu'on ne peut pas descendre en entier : la
+ * requête part après la frappe et s'annule si l'on continue à taper.
+ */
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface PaginationProps {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    previousLabel?: string;
+    nextLabel?: string;
+    /**
+     * Ajoute un champ pour sauter directement à une page.
+     *
+     * Sur quarante pages, atteindre la vingt-septième demande sinon de cliquer
+     * dans les ellipses jusqu'à ce qu'elle apparaisse.
+     */
+    jumpTo?: boolean;
+    /** Affiche « Page 3 sur 40 » à côté des numéros. */
+    showTotal?: boolean;
+    /** Masque les libellés et ne garde que les flèches. */
+    compact?: boolean;
+    /** Le nombre de lignes par page en vigueur. */
+    pageSize?: number;
+    /**
+     * Fourni avec `pageSize`, ajoute le choix du nombre de lignes par page.
+     *
+     * Seul le nouveau nombre est remonté : revenir en page 1 est l'affaire de
+     * qui tient l'état — `setPerPage` de `useTableQuery` le fait déjà.
+     */
+    onPageSizeChange?: (pageSize: number) => void;
+    /**
+     * Les tailles proposées. Par défaut `10, 20, 50, 100`. Une taille en
+     * vigueur absente de la liste y est ajoutée, pour que le champ ne paraisse
+     * jamais vide.
      */
-    renderValue?: (option: SelectOption | undefined) => ReactNode;
+    pageSizeOptions?: number[];
+    /** Le libellé du choix. Par défaut `locale.perPage` — « Par page ». */
+    pageSizeLabel?: string;
     /**
-     * `embedded` retire bordure, fond et largeur pleine du déclencheur : le
-     * `Select` se loge alors dans un autre contrôle — l'indicatif d'un
-     * `PhoneInput`, la taille de page d'une `Pagination`.
+     * Remplace entièrement le contrôle — des boutons segmentés, un champ libre.
+     * Le choix des tailles et leur tri sont déjà faits.
      */
-    variant?: "default" | "embedded";
+    renderPageSize?: (context: PageSizeContext) => ReactNode;
+    /**
+     * Le `Select` de taille de page : placement, variante, classe.
+     *
+     * La valeur, les options et le rappel restent calculés ici — on les règle
+     * par `pageSize`, `pageSizeOptions` et `onPageSizeChange`.
+     */
+    pageSizeSelectProps?: Partial<Omit<SelectProps, "value" | "defaultValue" | "options" | "children" | "onValueChange">>;
+    ariaLabel?: string;
     className?: string;
-    "aria-label"?: string;
-    "aria-describedby"?: string;
-    "aria-labelledby"?: string;
-    "aria-invalid"?: boolean;
-    "aria-required"?: boolean;
 }
+/** Ce que reçoit `renderPageSize`. */
+interface PageSizeContext {
+    pageSize: number;
+    options: number[];
+    onChange: (pageSize: number) => void;
+    label: string;
+}
+declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
 /**
- * Un choix parmi une liste.
- *
- * Le champ n'est pas un `<select>` natif : celui-ci ne sait ni chercher, ni
- * afficher une description sous chaque option, ni charger ses choix à la
- * demande. Le comportement clavier du natif, lui, est reproduit — flèches,
- * première lettre, échappement.
+ * La navigation entre les pages.
  *
- * `fetcher` sert les listes qu'on ne peut pas descendre en entier : la
- * requête part après la frappe et s'annule si l'on continue à taper.
+ * Le calcul des numéros et des ellipses vient de `@sia-ui/headless` :
+ * `usePagination` et ce composant appliquent la même règle, écrite une fois.
  */
-declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;
+declare function Pagination({ page, totalPages, onPageChange, siblingCount, previousLabel: previousLabelProp, nextLabel: nextLabelProp, jumpTo, showTotal, compact, pageSize, onPageSizeChange, pageSizeOptions, pageSizeLabel, renderPageSize, pageSizeSelectProps, ariaLabel, className, }: PaginationProps): react_jsx_runtime.JSX.Element | null;
 
 /** Une entrée de journal, dans sa forme la plus courante. */
 interface ActivityEntry {
@@ -362,11 +1069,52 @@ interface ActivityLogProps<T = ActivityEntry> {
     onRetry?: () => void;
     empty?: DataTableProps<T>["empty"];
     className?: string;
+    /** Les props du `PageHeader`, rendu quand `title` est fourni. */
+    pageHeaderProps?: Partial<PageHeaderProps>;
+    /**
+     * Les props de la `FiltersBar` — des actions, un autre libellé de
+     * réinitialisation. Sans `search`, `filters`, `activeCount` ni `onReset`,
+     * que le journal compose à partir de la requête.
+     */
+    filtersBarProps?: Partial<Omit<FiltersBarProps, "search" | "filters" | "activeCount" | "onReset">>;
+    /**
+     * Les props du champ de recherche. Sans `value`, `defaultValue`,
+     * `onValueChange` ni `onSearch` : la recherche en vigueur vit dans la
+     * requête.
+     */
+    searchInputProps?: Partial<Omit<SearchInputProps, "value" | "defaultValue" | "onValueChange" | "onSearch">>;
+    /**
+     * Les props communes aux `Select` des filtres. Sans `value`,
+     * `onValueChange` ni `options`, propres à chaque filtre et branchés sur la
+     * requête.
+     */
+    filterSelectProps?: Partial<Omit<SelectProps, "value" | "onValueChange" | "options">>;
+    /**
+     * Les props du `StatusBadge` de la colonne « Action » par défaut. Sans
+     * `value`, lue sur l'entrée. Sans effet quand `columns` est fourni.
+     */
+    actionBadgeProps?: Partial<Omit<StatusBadgeProps, "value">>;
+    /**
+     * Les props du `DataTable` — densité, mode cartes, sélection. Sans
+     * `columns` ni `data`, qui ont leurs props ici.
+     */
+    tableProps?: Partial<Omit<DataTableProps<T>, "columns" | "data">>;
+    /**
+     * Les props de la `Pagination` — `jumpTo`, `pageSizeOptions`. Sans la page
+     * et la taille de page ni leurs changements, branchés sur la requête.
+     */
+    paginationProps?: Partial<Omit<PaginationProps, "page" | "totalPages" | "onPageChange" | "pageSize" | "onPageSizeChange">>;
 }
 /** Les colonnes d'une `ActivityEntry` : quand, qui, quoi, sur quoi. */
 declare function activityColumns(options?: {
     actionTones?: Record<string, ComponentTone> | undefined;
     actionLabels?: Record<string, ReactNode> | undefined;
+    /** Les props du `StatusBadge` de la colonne « Action », sans `value`. */
+    actionBadgeProps?: Partial<Omit<StatusBadgeProps, "value">> | undefined;
+    /** Les en-têtes : le groupe `activityLog` de la locale. Français par défaut. */
+    messages?: ActivityLogMessages | undefined;
+    /** La langue des dates. Par défaut, `fr-FR`. */
+    language?: string | undefined;
 }): Array<DataTableColumn<ActivityEntry>>;
 /**
  * Un journal d'activité, filtrable et paginé par le serveur.
@@ -376,7 +1124,7 @@ declare function activityColumns(options?: {
  * Filtres déclarés, recherche temporisée, pagination et taille de page : tout
  * passe par la requête, rien n'est filtré dans le navigateur.
  */
-declare function ActivityLog<T = ActivityEntry>({ entries, query, totalPages, filters, searchPlaceholder, columns, getRowKey, actionTones, actionLabels, title, description, headingLevel, loading, error, onRetry, empty, className, }: ActivityLogProps<T>): react_jsx_runtime.JSX.Element;
+declare function ActivityLog<T = ActivityEntry>({ entries, query, totalPages, filters, searchPlaceholder, columns, getRowKey, actionTones, actionLabels, title, description, headingLevel, loading, error, onRetry, empty, className, pageHeaderProps, filtersBarProps, searchInputProps, filterSelectProps, actionBadgeProps, tableProps, paginationProps, }: ActivityLogProps<T>): react_jsx_runtime.JSX.Element;
 
 interface AlertProps {
     tone?: ComponentTone;
@@ -398,7 +1146,7 @@ declare function Alert({ tone, title, children, action, dismissLabel: dismissLab
 
 interface AmountDisplayProps {
     value: number;
-    currency?: string;
+    currency?: string; /** La langue du format. Par défaut, celle de la locale SIA. */
     locale?: string;
     label?: ReactNode;
     secondary?: ReactNode;
@@ -414,7 +1162,57 @@ interface AmountDisplayProps {
  * rouge seul. La couleur peut manquer — un daltonien, une impression en
  * noir et blanc — le signe, lui, reste.
  */
-declare function AmountDisplay({ value, currency, locale, label, secondary, sign, tone, className }: AmountDisplayProps): react_jsx_runtime.JSX.Element;
+declare function AmountDisplay({ value, currency, locale: localeProp, label, secondary, sign, tone, className }: AmountDisplayProps): react_jsx_runtime.JSX.Element;
+
+/** Ce que la réf impérative expose — ouvrir un tiroir depuis l'extérieur. */
+type DrawerRef = {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    isOpen: () => boolean;
+};
+type DrawerPosition = "left" | "right" | "top" | "bottom";
+type DrawerSize = "sm" | "md" | "lg" | "xl";
+interface DrawerProps extends React.HTMLAttributes<HTMLDivElement> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    position?: DrawerPosition;
+    size?: DrawerSize;
+    closeOnOutsideClick?: boolean;
+    closeOnEsc?: boolean;
+}
+/** Alias historique, attendu par les composants venus du registre. */
+type IDrawerProps = DrawerProps;
+type DrawerComponent = ForwardRefExoticComponent<IDrawerProps & RefAttributes<DrawerRef>> & {
+    Header: typeof DrawerHeader;
+    Body: typeof DrawerBody;
+    Footer: typeof DrawerFooter;
+    Title: typeof DrawerTitle;
+    Close: typeof DrawerClose;
+};
+/**
+ * Un panneau qui entre par un bord.
+ *
+ * Il sert là où une boîte modale serait trop : un filtre qu'on ajuste en
+ * regardant la liste derrière, un formulaire qu'on remplit sans perdre sa
+ * place. Le focus y est enfermé tant qu'il est ouvert, comme dans un
+ * modal — sans quoi la tabulation continue dans la page cachée.
+ */
+declare const Drawer: DrawerComponent;
+declare function DrawerHeader({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function DrawerTitle({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function DrawerBody({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function DrawerFooter({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function DrawerClose(): react_jsx_runtime.JSX.Element | null;
 
 interface SidebarItem {
     key: string;
@@ -490,6 +1288,14 @@ interface SidebarProps {
     collapsed?: boolean;
     /** De quel côté sortent les volets du rail. */
     side?: "left" | "right";
+    /**
+     * Réglages des volets du rail — placement, décalage, classe.
+     *
+     * L'objet descend jusqu'aux nœuds mémoïsés : le passer stable (constante,
+     * `useMemo`) plutôt qu'en littéral, sans quoi l'arbre se redessine à
+     * chaque rendu du parent.
+     */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
     variant?: "default" | "filled" | "floating";
     size?: "sm" | "md" | "lg";
     tone?: ComponentTone;
@@ -520,7 +1326,7 @@ interface SidebarProps {
  * profond que l'arborescence du produit, elle se réduit sans enfermer ses
  * sous-menus, et elle ne montre que ce que la session a le droit de voir.
  */
-declare function Sidebar({ items, activeKey, collapsed, side, variant, size, tone, can, openKeys, defaultOpenKeys, onOpenKeysChange, accordion, renderLink, header, footer, onNavigate, ariaLabel, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+declare function Sidebar({ items, activeKey, collapsed, side, overlayProps, variant, size, tone, can, openKeys, defaultOpenKeys, onOpenKeysChange, accordion, renderLink, header, footer, onNavigate, ariaLabel, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
 
 interface BottomTabsProps {
     /** Attendu déjà filtré : la coquille a fait le tri une seule fois. */
@@ -539,6 +1345,7 @@ interface BottomTabsProps {
     /** Le bouton qui ouvre l'arborescence complète. */
     more?: ReactNode;
     onMore?: () => void;
+    /** Le libellé de « Plus ». Par défaut, celui de la locale. */
     moreLabel?: string;
     className?: string;
 }
@@ -692,6 +1499,18 @@ interface AppShellProps {
     mobileNav?: AppShellMobileNav;
     /** Sous cette largeur, la barre latérale cède la place. */
     mobileBreakpoint?: number;
+    /**
+     * Réglages de la barre latérale — taille, ton, accordéon, branches
+     * ouvertes, volets du rail.
+     *
+     * Ce que la coquille décide seule en est retiré : les entrées filtrées,
+     * l'entrée active, l'état réduit, les liens, l'en-tête et le pied, le côté
+     * et la variante — tous déjà réglables ici, et qui doivent rester
+     * d'accord avec la mise en page de la coquille.
+     */
+    sidebarProps?: Partial<Omit<SidebarProps, "items" | "can" | "activeKey" | "collapsed" | "side" | "variant" | "renderLink" | "onNavigate" | "header" | "footer" | "ariaLabel">>;
+    /** Réglages du tiroir mobile — taille, fermeture au clic extérieur, classe. */
+    drawerProps?: Partial<Omit<DrawerProps, "open" | "defaultOpen" | "onOpenChange" | "children">>;
     ariaLabel?: string;
     className?: string;
 }
@@ -703,7 +1522,7 @@ interface AppShellProps {
  * l'assemblage — trois états de barre, une bascule mobile, et une seule
  * source de vérité pour ce qui est visible et pour ce qui est actif.
  */
-declare function AppShell({ nav, children, activeKey, currentPath, renderLink, onNavigate, can, brand, sidebarFooter, header, page, footer, contentWidth, side, variant, stickyHeader, sidebarState, defaultSidebarState, onSidebarStateChange, collapsible, sidebarWidth, sidebarCollapsedWidth, mobileNav, mobileBreakpoint, ariaLabel, className, }: AppShellProps): react_jsx_runtime.JSX.Element;
+declare function AppShell({ nav, children, activeKey, currentPath, renderLink, onNavigate, can, brand, sidebarFooter, header, page, footer, contentWidth, side, variant, stickyHeader, sidebarState, defaultSidebarState, onSidebarStateChange, collapsible, sidebarWidth, sidebarCollapsedWidth, mobileNav, mobileBreakpoint, sidebarProps, drawerProps, ariaLabel, className, }: AppShellProps): react_jsx_runtime.JSX.Element;
 
 interface AspectRatioProps {
     /** Le rapport largeur / hauteur. `16 / 9`, `1`, `4 / 3`. */
@@ -729,226 +1548,136 @@ interface AsyncStateProps {
     emptyDescription?: ReactNode;
     onRetry?: () => void;
     children: ReactNode;
+    /**
+     * Les props de l'`Alert` d'erreur — un autre titre, un autre ton. Sans
+     * `children` : le message est `error`.
+     */
+    alertProps?: Partial<Omit<AlertProps, "children">>;
+    /**
+     * Les props du bouton « Réessayer ». Sans `onClick`, branché sur
+     * `onRetry` : un bouton de reprise qui ne reprend rien serait pire que
+     * pas de bouton.
+     */
+    retryButtonProps?: Partial<Omit<ButtonProps, "onClick">>;
+    /** Les props de l'`EmptyState` — une icône, une action, la taille. */
+    emptyStateProps?: Partial<EmptyStateProps>;
+    /** Le témoin de chargement. Son libellé vient de la locale. */
+    spinnerProps?: Partial<Omit<SpinnerProps, "label">>;
 }
 /**
  * Les trois états d'un chargement, au même endroit.
  *
  * En attente, en erreur, ou vide : ce sont les mêmes trois cas à chaque
  * écran, et les écrire à la main en oublie toujours un — le plus souvent le
- * vide, qui ressemble à un chargement qui n'en finit pas.
- */
-declare function AsyncState({ loading, error, empty, emptyTitle, emptyDescription, onRetry, children }: AsyncStateProps): react_jsx_runtime.JSX.Element;
-
-interface AuditEvent {
-    label: ReactNode;
-    at: Date | string | number;
-    by?: ReactNode;
-    detail?: ReactNode;
-}
-interface AuditMetaProps {
-    events: AuditEvent[];
-    locale?: string;
-    title?: ReactNode;
-    emptyLabel?: ReactNode;
-    className?: string;
-}
-/**
- * Qui a fait quoi, et quand.
- *
- * Une liste d'événements plutôt qu'un dernier état : savoir qu'une facture
- * a été validée n'apprend rien si l'on ignore qu'elle avait été rejetée la
- * veille. Les dates sont relatives — « il y a deux jours » se compare sans
- * calcul mental.
- */
-declare function AuditMeta({ events, locale, title, emptyLabel, className }: AuditMetaProps): react_jsx_runtime.JSX.Element;
-
-interface AuthLayoutProps {
-    title: ReactNode;
-    description?: ReactNode;
-    logo?: ReactNode;
-    aside?: ReactNode;
-    children: ReactNode;
-    footer?: ReactNode;
-    className?: string;
-}
-/**
- * La page qui précède l'application : connexion, inscription, mot de passe
- * oublié.
- *
- * Elle n'a ni navigation ni coquille, et c'est délibéré : tout ce qui mène
- * ailleurs est hors de portée de quelqu'un qui n'est pas encore entré.
- */
-declare function AuthLayout({ title, description, logo, aside, children, footer, className, }: AuthLayoutProps): react_jsx_runtime.JSX.Element;
-
-interface AutocompleteProps {
-    id?: string;
-    options: SelectOption[];
-    value?: string;
-    defaultValue?: string;
-    onValueChange?: (value: string, option?: SelectOption) => void;
-    placeholder?: string;
-    allowCustomValue?: boolean;
-    disabled?: boolean;
-    className?: string;
-    "aria-describedby"?: string;
-    "aria-labelledby"?: string;
-    "aria-invalid"?: boolean;
-    "aria-required"?: boolean;
-}
-/**
- * Un champ qui propose, sans imposer.
- *
- * `allowCustomValue` est vrai par défaut : la liste aide à trouver, elle ne
- * dit pas ce qui existe. Un nom de client absent du référentiel reste
- * saisissable, quitte à être créé ensuite.
- */
-declare function Autocomplete({ id, options, value, defaultValue, onValueChange, placeholder: placeholderProp, allowCustomValue, disabled, className, ...ariaProps }: AutocompleteProps): react_jsx_runtime.JSX.Element;
-
-type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";
-type AvatarShape = "circle" | "rounded" | "square";
-type AvatarVariant = "soft" | "solid" | "outline";
-/**
- * La présence d'une personne.
- *
- * Quatre états et pas davantage : au-delà, la pastille devient un code que
- * personne ne retient, et il faut une légende pour la lire.
- */
-type AvatarStatus = "online" | "offline" | "busy" | "away";
-/**
- * Les teintes dérivées du nom.
- *
- * Deux personnes aux mêmes initiales doivent se distinguer : dans une liste
- * de participants, six pastilles identiques ne valent pas mieux qu'aucune.
- * La couleur est donc déterministe — la même personne garde la sienne d'un
- * écran à l'autre, d'une session à l'autre.
- */
-declare const TEINTES: readonly ["primary", "info", "success", "warning", "danger", "secondary"];
-type AvatarTint = (typeof TEINTES)[number];
-declare function tintForName(name: string): AvatarTint;
-declare function initialsOf(name: string, count?: number): string;
-interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "children" | "width" | "height"> {
-    /** Le nom de la personne : il sert au repli, à la couleur et à l'annonce. */
-    name: string;
-    size?: AvatarSize;
-    shape?: AvatarShape;
-    variant?: AvatarVariant;
-    /** Force la teinte au lieu de la dériver du nom. */
-    tint?: AvatarTint;
-    /** Remplace les initiales — une icône, un emoji, deux lettres à soi. */
-    fallback?: ReactNode;
-    /** Nombre d'initiales quand le repli est automatique. */
-    initials?: 1 | 2;
-    status?: AvatarStatus;
-    /** Le libellé du statut, pour les lecteurs d'écran. */
-    statusLabel?: string;
-    /** Un liseré qui détache l'avatar de son fond. */
-    ring?: boolean;
-    /** Rend l'avatar actionnable — un menu de compte, par exemple. */
-    onPress?: () => void;
-}
-/**
- * Le portrait d'une personne, ou ce qui le remplace.
- *
- * Une image met du temps à arriver, échoue parfois, et manque souvent. Les
- * trois cas sont traités sans que la mise en page bouge : l'espace est réservé
- * d'emblée, le repli est peint dessous, et l'image se fond par-dessus quand
- * elle arrive.
- */
-declare function Avatar({ name, size, shape, variant, tint, fallback, initials, status, statusLabel, ring, onPress, className, src, alt, onError, onLoad, style, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
-interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
-    children: ReactNode;
-    /**
-     * Au-delà, les suivants sont résumés par un compteur.
-     *
-     * Sans limite, une réunion de quarante personnes déborde de sa ligne et
-     * n'apprend plus rien : au-delà de cinq visages, on ne lit plus des gens,
-     * on lit une foule.
-     */
-    max?: number;
-    size?: AvatarSize;
-    shape?: AvatarShape;
-    variant?: AvatarVariant;
-    /** Le chevauchement, de 0 (côte à côte) à 1 (fortement empilés). */
-    overlap?: number;
-    /** Écarte les avatars au survol, pour les distinguer. */
-    spreadOnHover?: boolean;
-    /** Ce qu'affiche le compteur. Par défaut `+N`. */
-    renderOverflow?: (count: number) => ReactNode;
+ * vide, qui ressemble à un chargement qui n'en finit pas.
+ */
+declare function AsyncState({ loading, error, empty, emptyTitle, emptyDescription, onRetry, children, alertProps, retryButtonProps, emptyStateProps, spinnerProps }: AsyncStateProps): react_jsx_runtime.JSX.Element;
+
+interface AuditEvent {
+    label: ReactNode;
+    at: Date | string | number;
+    by?: ReactNode;
+    detail?: ReactNode;
+}
+interface AuditMetaProps {
+    events: AuditEvent[];
+    /** La langue des dates. Par défaut, celle de la locale SIA. */
+    locale?: string;
+    /** Par défaut, « Historique » de la locale SIA. */
+    title?: ReactNode;
+    /** Par défaut, « Aucune activité » de la locale SIA. */
+    emptyLabel?: ReactNode;
+    className?: string;
 }
 /**
- * Plusieurs personnes, sur une ligne.
+ * Qui a fait quoi, et quand.
  *
- * Les avatars se chevauchent — c'est ce qui dit « un groupe » plutôt qu'« une
- * liste ». Chacun porte un liseré de la couleur du fond, sans quoi la pile
- * devient une bouillie dès que deux teintes se ressemblent.
+ * Une liste d'événements plutôt qu'un dernier état : savoir qu'une facture
+ * a été validée n'apprend rien si l'on ignore qu'elle avait été rejetée la
+ * veille. Les dates sont relatives — « il y a deux jours » se compare sans
+ * calcul mental.
  */
-declare function AvatarGroup({ children, max, size, shape, variant, overlap, spreadOnHover, renderOverflow, className, style, ...props }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+declare function AuditMeta({ events, locale: localeProp, title: titleProp, emptyLabel: emptyLabelProp, className }: AuditMetaProps): react_jsx_runtime.JSX.Element;
 
-interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
-    label?: string;
-    size?: "xs" | "sm" | "md" | "lg" | "xl";
-    variant?: "dots" | "ring" | "double-ring";
-    tone?: ComponentTone | "current";
+interface AuthLayoutProps {
+    title: ReactNode;
+    description?: ReactNode;
+    logo?: ReactNode;
+    aside?: ReactNode;
+    children: ReactNode;
+    footer?: ReactNode;
+    className?: string;
 }
 /**
- * Une attente sans durée connue.
+ * La page qui précède l'application : connexion, inscription, mot de passe
+ * oublié.
  *
- * Quand la durée est connue, une barre de progression en dit plus. Le ton
- * `current` reprend la couleur du texte environnant : un indicateur posé
- * dans un bouton doit suivre la couleur du bouton, pas celle du thème.
+ * Elle n'a ni navigation ni coquille, et c'est délibéré : tout ce qui mène
+ * ailleurs est hors de portée de quelqu'un qui n'est pas encore entré.
  */
-declare function Spinner({ label: labelProp, size: sizeProp, variant: variantProp, tone: toneProp, className, ...props }: SpinnerProps): react_jsx_runtime.JSX.Element;
+declare function AuthLayout({ title, description, logo, aside, children, footer, className, }: AuthLayoutProps): react_jsx_runtime.JSX.Element;
 
-interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
-    tone?: ComponentTone;
-    variant?: "soft" | "solid" | "outline";
-    left?: ReactNode;
-    right?: ReactNode;
-    loading?: boolean;
-    loadingLabel?: string;
-    spinnerProps?: Omit<SpinnerProps, "label">;
+interface AutocompleteProps {
+    id?: string;
+    options: SelectOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string, option?: SelectOption) => void;
+    placeholder?: string;
+    allowCustomValue?: boolean;
+    disabled?: boolean;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
 }
 /**
- * Une étiquette d'état, courte et dense.
+ * Un champ qui propose, sans imposer.
  *
- * Elle porte un ton, jamais une action : un badge cliquable se confond avec
- * un bouton petit, et l'on découvre qu'il ne l'était pas en cliquant. Ce
- * qui agit est un bouton.
+ * `allowCustomValue` est vrai par défaut : la liste aide à trouver, elle ne
+ * dit pas ce qui existe. Un nom de client absent du référentiel reste
+ * saisissable, quitte à être créé ensuite.
  */
-declare function Badge({ tone: toneProp, variant: variantProp, left, right, loading, loadingLabel: loadingLabelProp, spinnerProps, className, children, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare function Autocomplete({ id, options, value, defaultValue, onValueChange, placeholder: placeholderProp, allowCustomValue, disabled, className, ...ariaProps }: AutocompleteProps): react_jsx_runtime.JSX.Element;
+
 /**
- * Le ton d'une valeur, lu dans une table de correspondance.
- *
- * Un statut, une action de journal, un environnement : chaque écran tenait
- * sa propre table et sa propre fonction pour la lire. Celle-ci est la seule.
- *
- * ```ts
- * const TONS = { payee: "success", attente: "warning", annulee: "danger" };
- * toneOf(TONS, facture.statut); // "success" | … | "neutral"
- * ```
+ * Une icône de marque, dans la forme d'un objet `simple-icons` : `path` est
+ * le tracé d'un SVG 24×24, `hex` la couleur de la marque, sans dièse.
  */
-declare function toneOf(tones: Readonly<Record<string, ComponentTone>> | undefined, value: unknown, fallback?: ComponentTone): ComponentTone;
-interface StatusBadgeProps extends Omit<BadgeProps, "tone" | "children"> {
-    /** La valeur brute : `"payee"`, `"prod"`, `"delete"`. */
-    value: string | number | null | undefined;
-    /** Le ton de chaque valeur. */
-    tones?: Readonly<Record<string, ComponentTone>>;
-    /** Le libellé de chaque valeur. À défaut, la valeur elle-même. */
-    labels?: Readonly<Record<string, ReactNode>>;
-    /** Le ton d'une valeur absente de `tones`. `neutral` par défaut. */
-    fallbackTone?: ComponentTone;
-    /** Ce qui s'affiche sans valeur. Rien par défaut. */
-    empty?: ReactNode;
+interface BrandIconData {
+    title: string;
+    path: string;
+    hex: string;
+}
+interface BrandIconProps extends Omit<SVGAttributes<SVGSVGElement>, "children" | "title"> {
+    icon: BrandIconData;
+    /** La taille du carré. `1em` par défaut : l'icône suit le texte. */
+    size?: number | string;
+    /** La couleur de la marque (défaut), ou `currentColor` quand il vaut `false`. */
+    colored?: boolean;
+    /** Le nom accessible. Par défaut, `icon.title`. */
+    title?: string;
+    /** Masquée des lecteurs d'écran : l'icône accompagne un texte qui la nomme déjà. */
+    decorative?: boolean;
 }
 /**
- * Une valeur rendue en pastille, ton et libellé tirés de deux tables.
+ * Le logo d'un service tiers — Vercel, Supabase, GitHub — sans dépendance.
  *
- * Déclarées une fois par domaine — les statuts de facture, les actions du
- * journal — puis passées partout où la valeur s'affiche : colonne libre,
- * détail, carte. Une valeur inconnue garde une pastille neutre plutôt que de
- * disparaître.
+ * Le système ne livre aucun logo : il prend l'objet d'icône que le projet
+ * importe lui-même, et ne dépend donc ni d'un paquet d'icônes ni de sa
+ * version.
+ *
+ * ```tsx
+ * import { siVercel } from "simple-icons";
+ * <BrandIcon icon={siVercel} />
+ * ```
+ *
+ * Une marque quasi noire (Vercel, GitHub) disparaîtrait sur un fond sombre,
+ * une marque quasi blanche sur un fond clair : sur le thème où elle serait
+ * illisible, elle prend la couleur du texte plutôt que la sienne.
  */
-declare function StatusBadge({ value, tones, labels, fallbackTone, empty, ...props }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+declare function BrandIcon({ icon, size, colored, title, decorative, className, style, ...props }: BrandIconProps): react_jsx_runtime.JSX.Element;
 
 interface BreadcrumbItem {
     key?: string;
@@ -968,6 +1697,11 @@ interface BreadcrumbProps {
     separator?: ReactNode;
     ariaLabel?: string;
     className?: string;
+    /**
+     * Le menu des niveaux repliés : placement, décalage, classe. Ses entrées
+     * et son déclencheur viennent de `items`.
+     */
+    dropdownMenuProps?: Partial<Omit<DropdownMenuProps, "items" | "children" | "onSelect">>;
 }
 /**
  * Le chemin parcouru.
@@ -975,60 +1709,7 @@ interface BreadcrumbProps {
  * Le dernier élément n'est jamais un lien : c'est la page courante, et un
  * lien vers l'endroit où l'on se trouve déjà n'existe pas.
  */
-declare function Breadcrumb({ items, maxVisible, separator, ariaLabel, className, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
-
-type TooltipVariant = "solid" | "outline";
-interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, "content"> {
-    content?: ReactNode;
-    children: ReactNode;
-    tone?: ComponentTone;
-    /** Seules `sm`, `md` et `lg` sont dessinées — voir `styles.css`. */
-    size?: ComponentSize;
-    placement?: Placement;
-    variant?: TooltipVariant;
-    /** Délai avant apparition, en millisecondes. */
-    delay?: number;
-    disabled?: boolean;
-}
-/** Alias historique, conservé pour les composants venus du registre. */
-type ITooltipProps = TooltipProps;
-type ITooltipVariant = TooltipVariant;
-/**
- * Bulle d'aide positionnée hors du flux.
- *
- * Le contenu passe par un portail plutôt que par un `position: absolute` dans
- * le flux : un tooltip posé dans une `Card` ou une cellule de `DataTable` —
- * toutes deux en `overflow: hidden` — serait sinon rogné.
- */
-declare function Tooltip({ content, children, placement, variant, tone, size, delay, disabled, className, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
-
-interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    variant?: "solid" | "outline" | "ghost";
-    /**
-     * Le ton sémantique de l'action.
-     *
-     * `.sia-button--danger` existait dans la feuille de style sans qu'aucune
-     * prop ne permette de l'atteindre : une action de suppression ne pouvait pas
-     * être rouge sans `className` manuel.
-     */
-    tone?: ComponentTone;
-    size?: "sm" | "md" | "lg";
-    radius?: "default" | "none" | "sm" | "lg" | "full";
-    loading?: boolean;
-    loadingLabel?: string;
-    spinnerProps?: Omit<SpinnerProps, "label">;
-    tooltip?: Omit<TooltipProps, "children">;
-    leftIcon?: ReactNode;
-    rightIcon?: ReactNode;
-}
-/**
- * L'action, sous toutes ses formes.
- *
- * Le chargement y est un état et non un remplacement : le bouton garde sa
- * taille et son libellé pendant l'appel. Un bouton qui devient un rond
- * tournant fait bouger la mise en page, et le clic suivant tombe à côté.
- */
-declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare function Breadcrumb({ items, maxVisible, separator, ariaLabel, className, dropdownMenuProps, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
 
 interface CalendarDay {
     date: string;
@@ -1071,6 +1752,7 @@ interface CalendarProps {
         onModeChange: (mode: CalendarMode) => void;
     }) => ReactNode;
     renderExtraFooter?: () => ReactNode;
+    /** La langue des jours et des mois. Par défaut, celle de la locale SIA. */
     locale?: string;
     firstDayOfWeek?: 0 | 1;
     showWeek?: boolean;
@@ -1089,8 +1771,12 @@ interface CalendarProps {
  * `Date` porte une heure et un fuseau dont une date de facture n'a que
  * faire, et qui la décalent d'un jour une fois sur deux.
  */
-declare function Calendar({ value, defaultValue, range, defaultRange, selectionMode, month, defaultMonth, mode, defaultMode, onValueChange, onRangeChange, onSelect, onMonthChange, onPanelChange, disabledDate, validRange, renderDay, cellRender, headerRender, renderExtraFooter, locale, firstDayOfWeek, showWeek, fullscreen, tone, className, }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare function Calendar({ value, defaultValue, range, defaultRange, selectionMode, month, defaultMonth, mode, defaultMode, onValueChange, onRangeChange, onSelect, onMonthChange, onPanelChange, disabledDate, validRange, renderDay, cellRender, headerRender, renderExtraFooter, locale: localeProp, firstDayOfWeek, showWeek, fullscreen, tone, className, }: CalendarProps): react_jsx_runtime.JSX.Element;
 
+type CardProps = HTMLAttributes<HTMLDivElement>;
+type CardHeaderProps = HTMLAttributes<HTMLDivElement>;
+type CardBodyProps = HTMLAttributes<HTMLDivElement>;
+type CardFooterProps = HTMLAttributes<HTMLDivElement>;
 /**
  * Une surface qui regroupe ce qui va ensemble.
  *
@@ -1099,10 +1785,10 @@ declare function Calendar({ value, defaultValue, range, defaultRange, selectionM
  * deux boutons et une pastille, une prop ne suffit plus, et l'on se retrouve
  * à passer du JSX à travers une chaîne.
  */
-declare function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-declare function CardBody({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-declare function CardFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function Card({ className, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ className, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+declare function CardBody({ className, ...props }: CardBodyProps): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ className, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
 
 interface ChartSeries {
     key: string;
@@ -1158,40 +1844,6 @@ interface SparklineProps {
  */
 declare function Sparkline({ values, tone, color, width, height, filled, className, }: SparklineProps): react_jsx_runtime.JSX.Element;
 
-type CheckboxValue = string | number;
-interface CheckboxGroupProps {
-    value?: CheckboxValue[];
-    defaultValue?: CheckboxValue[];
-    onValueChange?: (value: CheckboxValue[]) => void;
-    disabled?: boolean;
-    variant?: "default" | "button";
-    orientation?: "horizontal" | "vertical";
-    size?: "sm" | "md" | "lg";
-    tone?: ComponentTone;
-    className?: string;
-    children: ReactNode;
-}
-/**
- * Une case, ou un groupe de cases.
- *
- * `CheckboxGroup` gère la liste des valeurs cochées; la case seule gère la
- * sienne. L'état indéterminé est une troisième valeur, pas un entre-deux
- * visuel : il dit « certains enfants sont cochés », ce qu'aucun booléen ne
- * sait exprimer.
- */
-declare function CheckboxGroup({ value, defaultValue, onValueChange, disabled, variant, orientation, size, tone, className, children, }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
-interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "size"> {
-    value?: CheckboxValue;
-    label?: ReactNode;
-    children?: ReactNode;
-    description?: ReactNode;
-    indeterminate?: boolean;
-    onValueChange?: (checked: boolean) => void;
-    size?: "sm" | "md" | "lg";
-    tone?: ComponentTone;
-}
-declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
-
 interface ColorPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
     onValueChange?: (value: string) => void;
     showValue?: boolean;
@@ -1217,8 +1869,8 @@ interface CommandItem {
 interface CommandPaletteProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;
-    items: CommandItem[];
-    placeholder?: string;
+    items: CommandItem[]; /** Par défaut, celui de la locale. */
+    placeholder?: string; /** Par défaut, celui de la locale. */
     emptyLabel?: string;
     className?: string;
 }
@@ -1229,27 +1881,23 @@ interface CommandPaletteProps {
  * « facture » doit trouver « Nouvelle vente » sans avoir appris comment
  * l'action s'appelle ici.
  */
-declare function CommandPalette({ open, onOpenChange, items, placeholder, emptyLabel, className }: CommandPaletteProps): react_jsx_runtime.JSX.Element | null;
+declare function CommandPalette({ open, onOpenChange, items, placeholder: placeholderProp, emptyLabel: emptyLabelProp, className }: CommandPaletteProps): react_jsx_runtime.JSX.Element | null;
 
-interface ConfirmDialogProps {
-    open: boolean;
-    onOpenChange: (open: boolean) => void;
-    title: ReactNode;
-    description?: ReactNode;
-    confirmLabel?: string;
-    cancelLabel?: string;
-    tone?: Extract<ComponentTone, "primary" | "danger">;
-    loading?: boolean;
-    onConfirm: () => void | Promise<void>;
+interface ColorModeToggleProps extends Partial<Omit<IconButtonProps, "icon" | "onClick" | "aria-pressed">> {
+    /** Le nom du bouton en mode clair. Par défaut, celui de la locale. */
+    darkLabel?: string;
+    /** Le nom du bouton en mode sombre. Par défaut, celui de la locale. */
+    lightLabel?: string;
 }
 /**
- * La question qu'on pose avant de détruire.
+ * Le bouton de bascule clair / sombre.
  *
- * `onConfirm` peut rendre une promesse : le bouton reste occupé tant qu'elle
- * n'a pas abouti. Sans cela, la boîte se referme sur un appel encore en
- * vol, et l'on ignore si la suppression a eu lieu.
+ * Il lit et écrit le mode de `SiaProvider` — persistance et script
+ * anti-clignotement compris — plutôt que de tenir le sien. L'icône montre le
+ * mode vers lequel on part, comme le libellé : le soleil en mode sombre.
+ * Toutes les props d'`IconButton` passent, sauf ce qu'il pilote.
  */
-declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel: confirmLabelProp, cancelLabel: cancelLabelProp, tone, loading, onConfirm }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+declare function ColorModeToggle({ darkLabel: darkLabelProp, lightLabel: lightLabelProp, variant, ...props }: ColorModeToggleProps): react_jsx_runtime.JSX.Element;
 
 /**
  * La largeur de lecture, et l'espacement vertical.
@@ -1336,7 +1984,7 @@ declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.Re
 interface CurrencyInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "inputMode"> {
     value?: number | null;
     defaultValue?: number | null;
-    currency?: string;
+    currency?: string; /** La langue du format et de la saisie. Par défaut, celle de la locale SIA. */
     locale?: string;
     onValueChange?: (value: number | null) => void;
     invalid?: boolean;
@@ -1360,12 +2008,15 @@ interface DatePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek
     onValueChange?: (value: string) => void;
     onOpenChange?: (open: boolean) => void;
     open?: boolean;
+    /** Par défaut, « Sélectionner une date » de la locale SIA. */
     placeholder?: string;
     formatValue?: (value: string, locale: string) => ReactNode;
     allowClear?: boolean;
     showToday?: boolean;
     renderExtraFooter?: () => ReactNode;
     placement?: OverlayPlacement;
+    /** Réglages du panneau flottant — décalage, marge au bord, classe. */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
     tone?: ComponentTone;
     invalid?: boolean;
     disabled?: boolean;
@@ -1399,6 +2050,7 @@ interface TimePickerProps {
     hourFormat?: 12 | 24;
     needConfirm?: boolean;
     allowClear?: boolean;
+    /** Par défaut, « Sélectionner une heure » de la locale SIA. */
     placeholder?: string;
     disabledTime?: (value: TimeParts) => boolean;
     renderExtraFooter?: () => ReactNode;
@@ -1406,6 +2058,8 @@ interface TimePickerProps {
     onOpenChange?: (open: boolean) => void;
     open?: boolean;
     placement?: OverlayPlacement;
+    /** Réglages du panneau flottant — décalage, marge au bord, classe. */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
     tone?: ComponentTone;
     invalid?: boolean;
     disabled?: boolean;
@@ -1463,7 +2117,10 @@ interface MultiSelectProps {
     value?: string[];
     defaultValue?: string[];
     onValueChange?: (value: string[]) => void;
+    /** Le texte du champ vide. Par défaut, `select` de la locale. */
     placeholder?: string;
+    /** Le texte indicatif de la recherche. Par défaut, `searchPlaceholder` de la locale. */
+    searchPlaceholder?: string;
     searchable?: boolean;
     disabled?: boolean;
     className?: string;
@@ -1479,7 +2136,7 @@ interface MultiSelectProps {
  * un compte seul — « 3 sélectionnés » — oblige à rouvrir la liste pour
  * savoir lesquels.
  */
-declare function MultiSelect({ id, options, value, defaultValue, onValueChange, placeholder, searchable, disabled, className, ...ariaProps }: MultiSelectProps): react_jsx_runtime.JSX.Element;
+declare function MultiSelect({ id, options, value, defaultValue, onValueChange, placeholder: placeholderProp, searchPlaceholder: searchPlaceholderProp, searchable, disabled, className, ...ariaProps }: MultiSelectProps): react_jsx_runtime.JSX.Element;
 
 type RadioValue = string | number;
 interface RadioGroupProps {
@@ -1538,8 +2195,12 @@ interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onC
 declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
 
 interface FileUploadProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    /** Le titre de la zone. Par défaut, celui de la locale (`fileUpload.title`). */
     label?: string;
+    /** La phrase d'aide. Par défaut, celle de la locale (`fileUpload.description`). */
     description?: string;
+    /** Le bouton qui ouvre le sélecteur. Par défaut, celui de la locale (`fileUpload.browse`). */
+    browseLabel?: string;
     onFilesChange?: (files: File[]) => void;
 }
 /**
@@ -1549,13 +2210,22 @@ interface FileUploadProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "t
  * ignore le geste que tout le monde essaie d'abord. Les deux mènent au même
  * champ natif.
  */
-declare function FileUpload({ label, description, onFilesChange, className, multiple, accept, disabled, ...props }: FileUploadProps): react_jsx_runtime.JSX.Element;
+declare function FileUpload({ label: labelProp, description: descriptionProp, browseLabel: browseLabelProp, onFilesChange, className, multiple, accept, disabled, ...props }: FileUploadProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Les props de `FileUpload`, transmises telles quelles au dépôt : libellé,
+ * description, désactivation. `onFilesChange` cède la place à
+ * `onValueChange`, qui porte l'aperçu, et `multiple` est forcé à `false` —
+ * un aperçu ne montre qu'une image.
+ */
 interface ImageUploadProps extends Omit<FileUploadProps, "accept" | "onFilesChange"> {
     accept?: string;
     value?: string;
     onValueChange?: (file: File | null, previewUrl?: string) => void;
+    /** Le texte alternatif de l'aperçu. Par défaut, celui de la locale (`imageUpload.previewAlt`). */
     previewAlt?: string;
+    /** Le bouton qui retire l'image. Par défaut, `delete` de la locale. */
+    removeLabel?: string;
 }
 /**
  * Un dépôt de fichier qui montre ce qu'on vient de choisir.
@@ -1564,7 +2234,7 @@ interface ImageUploadProps extends Omit<FileUploadProps, "accept" | "onFilesChan
  * serveur pour afficher l'image laisse un carré vide au moment précis où
  * l'on veut vérifier qu'on n'a pas pris la mauvaise.
  */
-declare function ImageUpload({ accept, value, onValueChange, previewAlt, className, ...props }: ImageUploadProps): react_jsx_runtime.JSX.Element;
+declare function ImageUpload({ accept, value, onValueChange, previewAlt: previewAltProp, removeLabel: removeLabelProp, className, ...props }: ImageUploadProps): react_jsx_runtime.JSX.Element;
 
 type SliderRangeValue = [number, number];
 interface SliderProps {
@@ -1590,12 +2260,20 @@ interface SliderProps {
     showValue?: boolean | undefined;
     /** Rendu de la valeur affichée — devise, unité, arrondi. */
     formatValue?: ((value: number) => string) | undefined;
-    /** Libellé de la poignée basse, annoncé aux lecteurs d'écran. */
+    /**
+     * Libellé de la poignée basse, annoncé aux lecteurs d'écran. Par défaut,
+     * `slider.thumb` de la locale.
+     */
     startLabel?: string | undefined;
     /** Libellé de la poignée haute, en mode plage. */
     endLabel?: string | undefined;
     disabled?: boolean | undefined;
     className?: string | undefined;
+    /**
+     * Réglages de la bulle qui affiche la valeur au-dessus de chaque poignée —
+     * placement, ton, délai. Son contenu reste la valeur formatée.
+     */
+    tooltipProps?: Partial<Omit<TooltipProps, "content" | "children">> | undefined;
 }
 
 /**
@@ -1605,7 +2283,7 @@ interface SliderProps {
  * non-croisement — vit dans `useSliderState`. Ce fichier ne garde que ce qui
  * est propre au web : la mesure de la piste, les événements souris et le JSX.
  */
-declare function Slider({ name, value, defaultValue, min, max, step, range, minDistance, showValue, formatValue, startLabel, endLabel, onChange, onValueChange, disabled, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+declare function Slider({ name, value, defaultValue, min, max, step, range, minDistance, showValue, formatValue, startLabel, endLabel, onChange, onValueChange, disabled, className, tooltipProps, }: SliderProps): react_jsx_runtime.JSX.Element;
 
 interface RatingProps {
     id?: string;
@@ -1617,6 +2295,7 @@ interface RatingProps {
     allowHalf?: boolean;
     allowClear?: boolean;
     disabled?: boolean;
+    /** Le nom du groupe d'étoiles. Par défaut, celui de la locale. */
     label?: string;
     className?: string;
     "aria-describedby"?: string;
@@ -1630,7 +2309,7 @@ interface RatingProps {
  * `allowClear` rend la note réversible : sans lui, cliquer une étoile par
  * erreur est définitif, puisqu'aucune étoile ne vaut « aucune note ».
  */
-declare function Rating({ id, value, defaultValue, onValueChange, max, allowHalf, allowClear, disabled, label, className, ...ariaProps }: RatingProps): react_jsx_runtime.JSX.Element;
+declare function Rating({ id, value, defaultValue, onValueChange, max, allowHalf, allowClear, disabled, label: labelProp, className, ...ariaProps }: RatingProps): react_jsx_runtime.JSX.Element;
 
 interface RichTextEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
     value?: string;
@@ -1646,13 +2325,18 @@ interface RichTextEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onCh
  * renvoie et s'affiche partout ailleurs sans qu'un convertisseur soit
  * nécessaire.
  */
-declare function RichTextEditor({ value, defaultValue, onValueChange, placeholder, disabled, className, ...props }: RichTextEditorProps): react_jsx_runtime.JSX.Element;
+declare function RichTextEditor({ value, defaultValue, onValueChange, placeholder: placeholderProp, disabled, className, ...props }: RichTextEditorProps): react_jsx_runtime.JSX.Element;
 
 interface MarkdownEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange"> {
     value?: string;
     defaultValue?: string;
     onValueChange?: (value: string) => void;
     preview?: (value: string) => ReactNode;
+    /**
+     * La zone de saisie elle-même : `resize`, `invalid`, classe. La valeur et
+     * la saisie restent à l'éditeur, qui les partage avec l'aperçu.
+     */
+    textareaProps?: Partial<Omit<TextareaProps, "value" | "defaultValue" | "onChange">>;
 }
 /**
  * Une saisie Markdown, avec son aperçu.
@@ -1661,13 +2345,20 @@ interface MarkdownEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaEl
  * veut. Embarquer un moteur Markdown imposerait le nôtre à un projet qui a
  * déjà le sien — et ferait grossir le paquet pour tous les autres.
  */
-declare function MarkdownEditor({ value, defaultValue, onValueChange, preview, className, ...props }: MarkdownEditorProps): react_jsx_runtime.JSX.Element;
+declare function MarkdownEditor({ value, defaultValue, onValueChange, preview, className, textareaProps, ...props }: MarkdownEditorProps): react_jsx_runtime.JSX.Element;
 
 interface JsonEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange"> {
     value?: string;
     defaultValue?: string;
     onValueChange?: (value: string, parsed: unknown | undefined) => void;
     formatOnBlur?: boolean;
+    /**
+     * La zone de saisie elle-même : `resize`, classe, correcteur.
+     *
+     * La valeur, la saisie et `invalid` suivent l'analyse du JSON ; `onBlur`
+     * se passe au composant, qui l'enchaîne après le formatage.
+     */
+    textareaProps?: Partial<Omit<TextareaProps, "value" | "defaultValue" | "onChange" | "invalid" | "onBlur">>;
 }
 /**
  * Une zone de saisie qui connaît la forme de ce qu'on y écrit.
@@ -1676,7 +2367,7 @@ interface JsonEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElemen
  * analysé à côté du texte : l'appelant reçoit donc les deux, et n'a pas à
  * refaire un `JSON.parse` dans un `try`.
  */
-declare function JsonEditor({ value, defaultValue, onValueChange, formatOnBlur, className, ...props }: JsonEditorProps): react_jsx_runtime.JSX.Element;
+declare function JsonEditor({ value, defaultValue, onValueChange, formatOnBlur, className, textareaProps, ...props }: JsonEditorProps): react_jsx_runtime.JSX.Element;
 
 interface OtpInputProps {
     id?: string;
@@ -1724,11 +2415,16 @@ interface TagsInputProps {
  * que ce sont les deux touches que l'on presse sans y penser après avoir
  * tapé un mot.
  */
-declare function TagsInput({ id, value, defaultValue, onValueChange, placeholder, separators, maxTags, disabled, className, ...ariaProps }: TagsInputProps): react_jsx_runtime.JSX.Element;
+declare function TagsInput({ id, value, defaultValue, onValueChange, placeholder: placeholderProp, separators, maxTags, disabled, className, ...ariaProps }: TagsInputProps): react_jsx_runtime.JSX.Element;
 
 interface ReferenceOption extends SelectOption {
     description?: ReactNode;
 }
+/**
+ * Les props d'`Autocomplete`, transmises telles quelles : le composant n'est
+ * qu'une mise en forme de ses options. Seules `options` changent de forme,
+ * pour porter une description.
+ */
 interface ReferenceSelectProps extends Omit<AutocompleteProps, "options"> {
     options: ReferenceOption[];
 }
@@ -1751,7 +2447,21 @@ type FieldControlProps = {
     "aria-required"?: boolean;
 };
 type FieldValue = string | number | SliderRangeValue | boolean | string[] | DateTimeValue | File[] | File | null | undefined;
-type ControlProps = Partial<InputProps & TextareaProps & CurrencyInputProps & DatePickerProps & TimePickerProps & DateTimePickerProps & SelectProps & MultiSelectProps & RadioGroupProps & CheckboxProps & SwitchProps & FileUploadProps & ImageUploadProps & SliderProps & RatingProps & ColorPickerProps & RichTextEditorProps & MarkdownEditorProps & JsonEditorProps & OtpInputProps & TagsInputProps & AutocompleteProps & ReferenceSelectProps>;
+/**
+ * Ce que le champ décide seul pour son contrôle, quel qu'il soit.
+ *
+ * La valeur et son changement viennent de `value`/`onValueChange` ou du
+ * branchement `field` ; le nom, l'identifiant, les options, le texte
+ * indicatif et la désactivation ont chacun leur prop sur `Field`. Les
+ * laisser passer aussi par `controlProps` donnerait deux sources pour la
+ * même chose, dont l'une serait silencieusement écrasée.
+ */
+type FieldPilotedKey = "value" | "defaultValue" | "onChange" | "onValueChange" | "onCheckedChange" | "onFilesChange" | "checked" | "defaultChecked" | "name" | "id" | "options" | "placeholder" | "disabled" | "children";
+/**
+ * Distributif : un `Omit` posé sur l'union entière n'en garderait que les
+ * clés communes, et `searchable` ou `maxLength` disparaîtraient.
+ */
+type FieldControlSlot<P> = P extends unknown ? Partial<Omit<P, FieldPilotedKey>> : never;
 /**
  * Un branchement de formulaire, quel que soit le type exact de sa valeur.
  *
@@ -1797,6 +2507,7 @@ interface FieldProps {
     success?: ReactNode;
     required?: boolean;
     optional?: boolean;
+    /** La mention des champs facultatifs. Par défaut, `optional` de la locale. */
     optionalLabel?: ReactNode;
     htmlFor?: string;
     orientation?: "vertical" | "horizontal";
@@ -1810,9 +2521,20 @@ interface FieldProps {
     controlLabel?: ReactNode;
     placeholder?: string;
     disabled?: boolean;
-    controlProps?: ControlProps;
+    /**
+     * Réglages du contrôle que `type` choisit — `searchable` d'un `Select`,
+     * `maxLength` d'un `Input`, `accept` d'un `FileUpload`. Pour `radio`, ils
+     * vont au `RadioGroup`.
+     *
+     * Appliqués sous ce que le champ pilote : valeur, changement, nom,
+     * identifiant, options, texte indicatif et désactivation gardent leurs
+     * props dédiées. Ignorés quand le contrôle est fourni en `children`.
+     */
+    controlProps?: FieldControlSlot<InputProps | TextareaProps | CurrencyInputProps | DatePickerProps | TimePickerProps | DateTimePickerProps | SelectProps | MultiSelectProps | RadioGroupProps | CheckboxProps | SwitchProps | FileUploadProps | ImageUploadProps | SliderProps | RatingProps | ColorPickerProps | RichTextEditorProps | MarkdownEditorProps | JsonEditorProps | OtpInputProps | TagsInputProps | AutocompleteProps | ReferenceSelectProps>;
     children?: ReactElement<FieldControlProps>;
 }
+/** Les réglages qu'accepte `controlProps`, pour les composer hors du JSX. */
+type FieldControlOverrides = NonNullable<FieldProps["controlProps"]>;
 /**
  * Le champ, et tout ce qui l'entoure.
  *
@@ -1834,6 +2556,17 @@ interface FormFieldConfig extends Omit<FieldProps, "field" | "name"> {
     /** Nombre de colonnes occupées. Ignoré sur une seule colonne. */
     colSpan?: number;
     rowSpan?: number;
+    /**
+     * Une vérification qui demande le serveur — un identifiant libre, un nom
+     * de domaine disponible. Rend le message d'erreur, ou rien.
+     *
+     * Relancée après la frappe (`asyncValidationDelay`), annulée à la frappe
+     * suivante par son `signal`. Pendant la vérification le champ l'annonce,
+     * et l'envoi attend ; une valeur refusée bloque l'envoi.
+     */
+    validateAsync?: AsyncFieldValidator<FieldValue>;
+    /** Affiché sous le champ quand `validateAsync` accepte la valeur. */
+    validText?: ReactNode;
 }
 /** Un groupe de champs, avec son titre et sa propre grille. */
 interface FormFieldGroup {
@@ -1875,10 +2608,18 @@ interface FormProps<TValues extends FormShape = FormShape> {
      */
     onSubmit?: (values: TValues) => FormSubmitResult<TValues> | Promise<FormSubmitResult<TValues>>;
     columns?: number;
+    /** Le texte du bouton d'envoi. Par défaut, `save` de la locale. */
     submitText?: ReactNode;
+    /** Le texte du bouton de remise à zéro. Par défaut, `reset` de la locale. */
     clearText?: ReactNode;
     showClear?: boolean;
+    /**
+     * Les props du bouton d'envoi. `disabled` s'ajoute aux conditions du
+     * formulaire au lieu d'être remplacé par elles.
+     */
     submitProps?: ButtonProps;
+    /** Millisecondes sans frappe avant une vérification `validateAsync`. 400 par défaut. */
+    asyncValidationDelay?: number;
     /** Remplace entièrement la barre de boutons. */
     actions?: ReactNode;
     loading?: boolean;
@@ -1887,6 +2628,26 @@ interface FormProps<TValues extends FormShape = FormShape> {
     /** Désactive l'envoi tant qu'une erreur est en vigueur. */
     requireValid?: boolean;
     className?: string;
+    /**
+     * Les props communes à tous les champs — orientation, libellé
+     * « facultatif », `controlProps`. Chaque champ déclaré dans `fields`
+     * l'emporte sur elles.
+     *
+     * Sans ce que le formulaire branche lui-même : le nom, la valeur, le
+     * changement et la sortie de champ (`field`), ni les messages d'erreur et
+     * de validation, qui sont propres à chaque champ.
+     */
+    fieldProps?: Partial<Omit<FieldProps, "field" | "name" | "value" | "defaultValue" | "onValueChange" | "onBlur" | "error" | "success" | "message">>;
+    /**
+     * Les props de l'`Alert` qui annonce un échec d'envoi. Sans `children`, le
+     * message d'échec, ni `onDismiss`, qui l'efface.
+     */
+    alertProps?: Partial<Omit<AlertProps, "children" | "onDismiss">>;
+    /**
+     * Les props du `Spinner` d'une vérification `validateAsync` en cours.
+     * Sans `label`, repris de la locale comme le texte qui l'accompagne.
+     */
+    spinnerProps?: Partial<Omit<SpinnerProps, "label">>;
 }
 /**
  * Un formulaire décrit par ses champs.
@@ -1908,7 +2669,7 @@ interface FormProps<TValues extends FormShape = FormShape> {
  * />
  * ```
  */
-declare function Form<TValues extends FormShape = FormShape>({ fields, form: adapter, defaultValues, validate, onSubmit, columns, submitText, clearText, showClear, submitProps, actions, loading, requireDirty, requireValid, className, }: FormProps<TValues>): react_jsx_runtime.JSX.Element;
+declare function Form<TValues extends FormShape = FormShape>({ fields, form: adapter, defaultValues, validate, onSubmit, columns, submitText, clearText, showClear, submitProps, actions, loading, requireDirty, requireValid, asyncValidationDelay, className, fieldProps, alertProps, spinnerProps, }: FormProps<TValues>): react_jsx_runtime.JSX.Element;
 
 /**
  * La description d'un objet métier, écrite une seule fois.
@@ -1998,6 +2759,13 @@ interface ResourceField<T = unknown> {
     tones?: Record<string, ComponentTone>;
     /** Le rendu en tableau et en détail. Écrase celui déduit du type. */
     render?: (row: T, index: number) => ReactNode;
+    /**
+     * Les props du contrôle de saisie, transmises telles quelles par le
+     * formulaire : `{ searchable: true }` pour un `select` long, `{ maxLength }`
+     * pour un texte. Sans elles, régler le contrôle obligeait à redéclarer tous
+     * les champs dans la page.
+     */
+    controlProps?: FieldControlOverrides;
     /**
      * Une valeur calculée plutôt que lue sur la ligne.
      *
@@ -2087,8 +2855,12 @@ declare function resourceFormFields<T>(resource: ResourceDefinition<T>, mode?: R
  *
  * Un champ `email` valide une adresse sans qu'on le demande : le type le dit
  * déjà. Les règles déclarées s'y ajoutent, elles ne les remplacent pas.
+ *
+ * `messages` — `locale.resource`, lu avec `useSiaLocale()` — donne leurs
+ * textes aux règles imposées ; `CrudPage` le passe. À défaut, les messages
+ * par défaut de `@sia-ui/utils/validation`.
  */
-declare function resourceValidator<T>(resource: ResourceDefinition<T>, mode?: ResourceFormMode): FormValidator<FormShape> | undefined;
+declare function resourceValidator<T>(resource: ResourceDefinition<T>, mode?: ResourceFormMode, messages?: ResourceMessages): FormValidator<FormShape> | undefined;
 /** Les clés que la recherche locale parcourt. */
 declare function resourceSearchKeys<T>(resource: ResourceDefinition<T>): string[];
 /** Les valeurs de départ d'une création : les champs du mode `create`. */
@@ -2109,6 +2881,28 @@ declare function resourcePermissions<T>(resource: ResourceDefinition<T>): {
     delete?: PermissionRule;
 };
 
+interface DescriptionItem {
+    key: string;
+    label: ReactNode;
+    value: ReactNode;
+    span?: 1 | 2 | 3;
+}
+interface DescriptionsProps {
+    items: DescriptionItem[];
+    title?: ReactNode;
+    columns?: 1 | 2 | 3;
+    bordered?: boolean;
+    className?: string;
+}
+/**
+ * Des paires libellé / valeur, en colonnes.
+ *
+ * C'est la forme d'une fiche en lecture — ce qu'un formulaire montre quand
+ * il n'y a rien à saisir. `span` laisse une valeur longue occuper toute la
+ * ligne plutôt que d'être coupée dans une colonne étroite.
+ */
+declare function Descriptions({ items, title, columns, bordered, className }: DescriptionsProps): react_jsx_runtime.JSX.Element;
+
 /** Laquelle des trois boîtes est ouverte, et sur quelle ligne. */
 interface CrudDialogState<T> {
     mode: "create" | "edit" | "view";
@@ -2129,6 +2923,26 @@ interface CrudDialogOptions {
     /** Colonnes de la vue de détail. */
     detailColumns?: 1 | 2 | 3;
 }
+/**
+ * Les props des deux `Modal` — formulaire et détail — qu'on peut régler.
+ *
+ * Sans `open` ni `onOpenChange`, qui suivent l'état des boîtes, ni
+ * `children`. Sans `title` ni `description` non plus : ils diffèrent d'une
+ * boîte à l'autre et se règlent par `dialog`. `className` s'ajoute à celui
+ * des boîtes.
+ */
+type CrudModalProps = Partial<Omit<ModalProps, "open" | "onOpenChange" | "children" | "title" | "description">>;
+/**
+ * Les props du `Form` de création et de modification qu'on peut régler —
+ * `showClear`, `submitProps`, `fieldProps`.
+ *
+ * Sans ce que la boîte branche elle-même : les champs, les valeurs de
+ * départ, la validation et l'envoi, qui ont leurs props sur la page ; ni
+ * l'adaptateur `form`, qui couperait la boîte de ses propres valeurs.
+ */
+type CrudFormProps = Partial<Omit<FormProps, "fields" | "defaultValues" | "validate" | "onSubmit" | "form">>;
+/** Les props de la vue de détail par défaut. Sans `items`, tirés des colonnes. */
+type CrudDescriptionsProps = Partial<Omit<DescriptionsProps, "items">>;
 interface CrudDialogsProps<T> {
     state: CrudDialogState<T> | null;
     onClose: () => void;
@@ -2152,6 +2966,12 @@ interface CrudDialogsProps<T> {
     renderDetail?: ((row: T, index: number) => ReactNode) | undefined;
     getRowKey?: ((row: T, index: number) => Key) | undefined;
     dialog?: CrudDialogOptions | undefined;
+    /** Voir `CrudModalProps`. */
+    modalProps?: CrudModalProps | undefined;
+    /** Voir `CrudFormProps`. */
+    formProps?: CrudFormProps | undefined;
+    /** Voir `CrudDescriptionsProps`. */
+    descriptionsProps?: CrudDescriptionsProps | undefined;
 }
 /**
  * Les boîtes du CRUD : créer, modifier, consulter.
@@ -2161,7 +2981,7 @@ interface CrudDialogsProps<T> {
  * laquelle ouvrir, avec quelles valeurs, et de refermer une fois l'envoi
  * passé.
  */
-declare function CrudDialogs<T>({ state, onClose, columns, fields: champsCreation, validate: validationCreation, editFields, editValidate, onSubmit, createDefaults, toFormValues, renderDetail, getRowKey, dialog, }: CrudDialogsProps<T>): react_jsx_runtime.JSX.Element;
+declare function CrudDialogs<T>({ state, onClose, columns, fields: champsCreation, validate: validationCreation, editFields, editValidate, onSubmit, createDefaults, toFormValues, renderDetail, getRowKey, dialog, modalProps, formProps, descriptionsProps, }: CrudDialogsProps<T>): react_jsx_runtime.JSX.Element;
 
 /**
  * La personnalisation d'une action standard.
@@ -2312,7 +3132,32 @@ interface CrudPageBase<T> {
  * est là pour que TypeScript exige l'une ou l'autre — une page sans colonnes
  * ni ressource ne montrerait rien, et le dirait à l'exécution.
  */
-type CrudPageProps<T> = CrudPageBase<T> & ({
+type CrudPageProps<T> = CrudPageBase<T> & {
+    /**
+     * Les props du `PageHeader`. Sans `actions`, composées de
+     * `headerActions` et du bouton de création. `className` s'ajoute.
+     */
+    pageHeaderProps?: Partial<Omit<PageHeaderProps, "actions">>;
+    /**
+     * Les props du bouton de création. Sans `onClick`, qui ouvre le
+     * formulaire, ni `children` : le libellé passe par
+     * `operations.create.label`.
+     */
+    createButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+    /** Les props du bouton de suppression groupée. Sans `onClick`. */
+    bulkDeleteButtonProps?: Partial<Omit<ButtonProps, "onClick">>;
+    /**
+     * Les props de la `Pagination` — `jumpTo`, `compact`, `siblingCount`.
+     * Sans `page`, `totalPages` ni `onPageChange`, qui ont leurs props ici.
+     */
+    paginationProps?: Partial<Omit<PaginationProps, "page" | "totalPages" | "onPageChange">>;
+    /** Les props des `Modal` de formulaire et de détail — voir `CrudModalProps`. */
+    modalProps?: CrudModalProps;
+    /** Les props du `Form` des boîtes — voir `CrudFormProps`. */
+    formProps?: CrudFormProps;
+    /** Les props de la vue de détail par défaut — voir `CrudDescriptionsProps`. */
+    descriptionsProps?: CrudDescriptionsProps;
+} & ({
     /**
      * La ressource, déclarée une fois avec `defineResource`.
      *
@@ -2336,7 +3181,7 @@ type CrudPageProps<T> = CrudPageBase<T> & ({
  *
  * Ici, fournir le gestionnaire suffit. Ne pas le fournir retire l'action.
  */
-declare function CrudPage<T>({ resource, title, description, eyebrow, headingLevel, columns: colonnesFournies, data, getRowKey: cleFournie, onCreate, onView, onEdit, onDelete, fields: champsFournis, onSubmit, validate: validationFournie, createDefaults, toFormValues, detail, dialog, operations, extraRowActions, onBulkDelete, can, headerActions, toolbar, searchKeys: clesDeRecherche, searchPlaceholder, onSearch, searchDelay, loading, error, onRetry, empty, page, totalPages, onPageChange, pageSize, onPageSizeChange, pageSizeOptions, table, children, className, }: CrudPageProps<T>): react_jsx_runtime.JSX.Element;
+declare function CrudPage<T>({ resource, title, description, eyebrow, headingLevel, columns: colonnesFournies, data, getRowKey: cleFournie, onCreate, onView, onEdit, onDelete, fields: champsFournis, onSubmit, validate: validationFournie, createDefaults, toFormValues, detail, dialog, operations, extraRowActions, onBulkDelete, can, headerActions, toolbar, searchKeys: clesDeRecherche, searchPlaceholder, onSearch, searchDelay, loading, error, onRetry, empty, page, totalPages, onPageChange, pageSize, onPageSizeChange, pageSizeOptions, table, children, className, pageHeaderProps, createButtonProps, bulkDeleteButtonProps, paginationProps, modalProps, formProps, descriptionsProps, }: CrudPageProps<T>): react_jsx_runtime.JSX.Element;
 
 /**
  * L'état du tableau dans la barre d'adresse.
@@ -2425,7 +3270,7 @@ declare function useDataTableQuery(options?: UseDataTableQueryOptions): TableQue
  * elle filtre les lignes déjà chargées — ce qui suffit tant que tout tient
  * sur une page.
  */
-declare function DataTable<T>({ columns, data, getRowKey, title, description, toolbar, actions, searchKeys, searchPlaceholder, onSearch, searchDelay, layout, maxHeight, stickyHeader, density, striped, bordered, rowActions, inlineActionsLimit, actionsHeader, actionsDisplay, can, view: viewProp, defaultView, onViewChange, showViewToggle, responsive, cardsBreakpoint, renderCard, loading, skeletonRows, error, onRetry, empty, selectable, selectedKeys: selectedProp, defaultSelectedKeys, onSelectionChange, isRowSelectable, selectionActions, sort, onSortChange, onRowClick, rowClassName, caption, className, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare function DataTable<T>({ columns, data, getRowKey, title, description, toolbar, actions, searchKeys, searchPlaceholder, onSearch, searchDelay, searchInputProps, layout, maxHeight, stickyHeader, density, striped, bordered, rowActions, inlineActionsLimit, actionsHeader, actionsDisplay, rowActionButtonProps, rowActionIconButtonProps, rowActionsMenuProps, confirmDialogProps, can, view: viewProp, defaultView, onViewChange, showViewToggle, responsive, cardsBreakpoint, renderCard, loading, skeletonRows, skeletonProps, error, onRetry, errorStateProps, empty, emptyStateProps, selectable, selectedKeys: selectedProp, defaultSelectedKeys, onSelectionChange, isRowSelectable, checkboxProps, selectionActions, sort, onSortChange, onRowClick, rowClassName, caption, className, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
 
 type DateRangeValue = CalendarRangeValue;
 interface DateRangePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek" | "disabledDate" | "cellRender" | "showWeek"> {
@@ -2434,10 +3279,14 @@ interface DateRangePickerProps extends Pick<CalendarProps, "locale" | "firstDayO
     onValueChange?: (value: DateRangeValue) => void;
     min?: string;
     max?: string;
+    /** Par défaut, « Date de début » de la locale SIA. */
     startLabel?: string;
+    /** Par défaut, « Date de fin » de la locale SIA. */
     endLabel?: string;
     allowClear?: boolean;
     placement?: OverlayPlacement;
+    /** Réglages du panneau flottant — décalage, marge au bord, classe. */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
     tone?: ComponentTone;
     invalid?: boolean;
     disabled?: boolean;
@@ -2450,7 +3299,7 @@ interface DateRangePickerProps extends Pick<CalendarProps, "locale" | "firstDayO
  * faut alors décider lequel des deux avait tort. Ici les deux bornes sont
  * une seule valeur, et le calendrier les tient dans l'ordre.
  */
-declare function DateRangePicker({ value, defaultValue, onValueChange, min, max, startLabel, endLabel, allowClear, placement, tone, invalid, disabled, locale, firstDayOfWeek, disabledDate, cellRender, showWeek, className }: DateRangePickerProps): react_jsx_runtime.JSX.Element;
+declare function DateRangePicker({ value, defaultValue, onValueChange, min, max, startLabel: startLabelProp, endLabel: endLabelProp, allowClear, placement, overlayProps, tone, invalid, disabled, locale: localeProp, firstDayOfWeek, disabledDate, cellRender, showWeek, className }: DateRangePickerProps): react_jsx_runtime.JSX.Element;
 
 interface DateRangePreset {
     label: ReactNode;
@@ -2461,6 +3310,8 @@ interface DateRangeFilterProps {
     onValueChange: (value: DateRangeValue) => void;
     presets?: DateRangePreset[];
     onClear?: () => void;
+    /** Réglages du sélecteur de période — bornes, libellés, jours désactivés. */
+    dateRangePickerProps?: Partial<Omit<DateRangePickerProps, "value" | "defaultValue" | "onValueChange">>;
     className?: string;
 }
 /**
@@ -2470,29 +3321,7 @@ interface DateRangeFilterProps {
  * l'exercice — et les proposer évite de saisir deux dates pour la question
  * que tout le monde pose en premier.
  */
-declare function DateRangeFilter({ value, onValueChange, presets, onClear, className }: DateRangeFilterProps): react_jsx_runtime.JSX.Element;
-
-interface DescriptionItem {
-    key: string;
-    label: ReactNode;
-    value: ReactNode;
-    span?: 1 | 2 | 3;
-}
-interface DescriptionsProps {
-    items: DescriptionItem[];
-    title?: ReactNode;
-    columns?: 1 | 2 | 3;
-    bordered?: boolean;
-    className?: string;
-}
-/**
- * Des paires libellé / valeur, en colonnes.
- *
- * C'est la forme d'une fiche en lecture — ce qu'un formulaire montre quand
- * il n'y a rien à saisir. `span` laisse une valeur longue occuper toute la
- * ligne plutôt que d'être coupée dans une colonne étroite.
- */
-declare function Descriptions({ items, title, columns, bordered, className }: DescriptionsProps): react_jsx_runtime.JSX.Element;
+declare function DateRangeFilter({ value, onValueChange, presets, onClear, dateRangePickerProps, className }: DateRangeFilterProps): react_jsx_runtime.JSX.Element;
 
 interface DividerProps extends HTMLAttributes<HTMLDivElement> {
     orientation?: "horizontal" | "vertical";
@@ -2507,135 +3336,8 @@ interface DividerProps extends HTMLAttributes<HTMLDivElement> {
  */
 declare function Divider({ orientation, decorative, className, ...props }: DividerProps): react_jsx_runtime.JSX.Element;
 
-/** Ce que la réf impérative expose — ouvrir un tiroir depuis l'extérieur. */
-type DrawerRef = {
-    open: () => void;
-    close: () => void;
-    toggle: () => void;
-    isOpen: () => boolean;
-};
-type DrawerPosition = "left" | "right" | "top" | "bottom";
-type DrawerSize = "sm" | "md" | "lg" | "xl";
-interface DrawerProps extends React.HTMLAttributes<HTMLDivElement> {
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    position?: DrawerPosition;
-    size?: DrawerSize;
-    closeOnOutsideClick?: boolean;
-    closeOnEsc?: boolean;
-}
-/** Alias historique, attendu par les composants venus du registre. */
-type IDrawerProps = DrawerProps;
-type DrawerComponent = ForwardRefExoticComponent<IDrawerProps & RefAttributes<DrawerRef>> & {
-    Header: typeof DrawerHeader;
-    Body: typeof DrawerBody;
-    Footer: typeof DrawerFooter;
-    Title: typeof DrawerTitle;
-    Close: typeof DrawerClose;
-};
-/**
- * Un panneau qui entre par un bord.
- *
- * Il sert là où une boîte modale serait trop : un filtre qu'on ajuste en
- * regardant la liste derrière, un formulaire qu'on remplit sans perdre sa
- * place. Le focus y est enfermé tant qu'il est ouvert, comme dans un
- * modal — sans quoi la tabulation continue dans la page cachée.
- */
-declare const Drawer: DrawerComponent;
-declare function DrawerHeader({ children }: {
-    children: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function DrawerTitle({ children }: {
-    children: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function DrawerBody({ children }: {
-    children: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function DrawerFooter({ children }: {
-    children: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function DrawerClose(): react_jsx_runtime.JSX.Element | null;
-
-interface MenuItem {
-    key: string;
-    label: ReactNode;
-    icon?: ReactNode;
-    /** Un raccourci affiché à droite. Purement indicatif : rien n'est écouté. */
-    shortcut?: string;
-    disabled?: boolean;
-    danger?: boolean;
-    /** Affiche une coche. `undefined` : l'entrée n'est pas cochable. */
-    checked?: boolean;
-    description?: ReactNode;
-    onSelect?: () => void;
-}
-interface MenuSeparator {
-    key: string;
-    type: "separator";
-}
-interface MenuLabel {
-    key: string;
-    type: "label";
-    label: ReactNode;
-}
-type MenuEntry = MenuItem | MenuSeparator | MenuLabel;
-interface MenuListProps {
-    items: MenuEntry[];
-    onSelect: (item: MenuItem) => void;
-    onClose: () => void;
-    /** Index actif, piloté par le parent pour que le clavier suive. */
-    activeIndex: number;
-    onActiveIndexChange: (index: number) => void;
-    id?: string | undefined;
-    className?: string | undefined;
-}
-/**
- * Le panneau seul, sans déclencheur.
- *
- * Extrait parce que `DropdownMenu` et `ContextMenu` n'ont en commun que lui :
- * tout le reste — l'ancrage, le geste d'ouverture — diffère.
- */
-declare function MenuList({ items, onSelect, onClose, activeIndex, onActiveIndexChange, id, className, }: MenuListProps): react_jsx_runtime.JSX.Element;
-interface DropdownMenuProps {
-    items: MenuEntry[];
-    children: ReactElement<{
-        onClick?: () => void;
-        "aria-expanded"?: boolean;
-    }>;
-    onSelect?: (item: MenuItem) => void;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    placement?: OverlayPlacement;
-    matchTriggerWidth?: boolean;
-    className?: string;
-}
-/**
- * Un menu accroché à un bouton.
- *
- * Il repose sur `Overlay` : le repositionnement quand la place manque en bas,
- * la fermeture au clic extérieur et à Échap sont déjà là et ne sont pas
- * réécrites ici.
- */
-declare function DropdownMenu({ items, children, onSelect, open: openProp, defaultOpen, onOpenChange, placement, matchTriggerWidth, className, }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
-interface ContextMenuProps {
-    items: MenuEntry[];
-    children: ReactNode;
-    onSelect?: (item: MenuItem) => void;
-    className?: string;
-}
-/**
- * Le même menu, ouvert au clic droit sur une zone.
- *
- * L'ancre est un point, pas un élément : un repère de taille nulle est posé
- * aux coordonnées du pointeur et confié à `Overlay`, qui ne voit pas la
- * différence. C'est ce qui évite un second moteur de placement.
- */
-declare function ContextMenu({ items, children, onSelect, className, }: ContextMenuProps): react_jsx_runtime.JSX.Element;
-
 interface DurationDisplayProps {
-    milliseconds: number;
+    milliseconds: number; /** La langue des nombres et des unités. Par défaut, celle de la locale SIA. */
     locale?: string;
     style?: "short" | "long" | "clock";
     className?: string;
@@ -2646,24 +3348,7 @@ interface DurationDisplayProps {
  * Trois styles pour trois usages : `clock` pour un chronomètre qu'on lit en
  * continu, `short` pour une colonne de tableau, `long` pour une phrase.
  */
-declare function DurationDisplay({ milliseconds, locale, style, className }: DurationDisplayProps): react_jsx_runtime.JSX.Element;
-
-interface EmptyStateProps {
-    icon?: ReactNode;
-    title: ReactNode;
-    description?: ReactNode;
-    action?: ReactNode;
-    compact?: boolean;
-    className?: string;
-}
-/**
- * Ce qu'on montre quand il n'y a rien.
- *
- * Une liste vide sans explication ressemble à un chargement bloqué. Elle
- * porte donc une action : le vide initial est le meilleur moment pour
- * proposer de créer le premier élément.
- */
-declare function EmptyState({ icon, title, description, action, compact, className }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+declare function DurationDisplay({ milliseconds, locale: localeProp, style, className }: DurationDisplayProps): react_jsx_runtime.JSX.Element;
 
 interface EntityMetaProps {
     createdAt?: Date | string | number;
@@ -2672,6 +3357,7 @@ interface EntityMetaProps {
     updatedBy?: ReactNode;
     identifier?: string;
     status?: ReactNode;
+    /** La langue des dates. Par défaut, celle de la locale SIA. */
     locale?: string;
     className?: string;
 }
@@ -2682,65 +3368,208 @@ interface EntityMetaProps {
  * c'est la première chose qu'on demande à un client, et une chaîne de
  * trente-six caractères ne se dicte pas.
  */
-declare function EntityMeta({ createdAt, updatedAt, createdBy, updatedBy, identifier, status, locale, className }: EntityMetaProps): react_jsx_runtime.JSX.Element;
+declare function EntityMeta({ createdAt, updatedAt, createdBy, updatedBy, identifier, status, locale: localeProp, className }: EntityMetaProps): react_jsx_runtime.JSX.Element;
 
-interface ErrorStateProps {
+interface PopoverProps {
+    content: ReactNode;
     title?: ReactNode;
-    description?: ReactNode;
-    error?: unknown;
-    action?: ReactNode;
-    onRetry?: () => void;
-    retryLabel?: string;
-    compact?: boolean;
+    children: ReactElement<{
+        onClick?: () => void;
+        "aria-expanded"?: boolean;
+    }>;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: OverlayPlacement;
+    /** Réglages du panneau flottant — décalage, marge au bord, rôle, classe. */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
+    trigger?: "click" | "hover";
+    variant?: "solid" | "outline";
+    tone?: ComponentTone;
+    disabled?: boolean;
     className?: string;
 }
 /**
- * Un échec, et de quoi en sortir.
+ * Un panneau attaché à un élément, avec du contenu qu'on peut viser.
  *
- * `error` accepte n'importe quoi : une `Error`, une réponse HTTP, une
- * chaîne. Ce qui arrive d'un appel réseau n'a pas de forme garantie, et
- * exiger un type ferait écrire un `try` autour de chaque affichage
- * d'erreur.
+ * À la différence d'une infobulle, il reste ouvert : on y met un lien, un
+ * bouton, un petit formulaire. Une infobulle qui contient un bouton est une
+ * infobulle cassée — elle disparaît dès qu'on va vers lui.
  */
-declare function ErrorState({ title: titleProp, description, error, action, onRetry, retryLabel: retryLabelProp, compact, className }: ErrorStateProps): react_jsx_runtime.JSX.Element;
+declare function Popover({ content, title, children, open: openProp, defaultOpen, onOpenChange, placement, overlayProps, trigger, variant, tone, disabled, className }: PopoverProps): react_jsx_runtime.JSX.Element;
 
-interface CalendarEvent {
-    id: string;
-    date: string;
-    title: string;
-    tone?: ComponentTone;
-}
-interface EventCalendarProps extends Omit<CalendarProps, "renderDay"> {
-    events: CalendarEvent[];
+/** Un événement du calendrier. Les champs métier en plus passent tels quels. */
+interface CalendarEvent extends Omit<CalendarEventInput, "start"> {
+    /** `2026-09-30` pour la journée, `2026-09-30T14:30` pour une heure. */
+    start?: string | undefined;
+    /** @deprecated Ancien nom de `start`, gardé pour les projets existants. */
+    date?: string | undefined;
+    tone?: ComponentTone | undefined;
+    description?: ReactNode | undefined;
+    location?: ReactNode | undefined;
+}
+/**
+ * Les libellés du calendrier : le groupe `eventCalendar` de la locale SIA.
+ * « +N autres » se décline en `more_one` / `more_other`, avec `{count}`.
+ */
+type EventCalendarLabels = EventCalendarMessages;
+interface EventCalendarProps<T extends CalendarEvent = CalendarEvent> {
+    events: T[];
+    /** La vue affichée — mois, semaine, agenda. */
+    view?: CalendarView;
+    defaultView?: CalendarView;
+    onViewChange?: (view: CalendarView) => void;
+    /** Les vues proposées. Une seule masque le sélecteur. */
+    views?: CalendarView[];
+    /**
+     * L'habillage de la grille. `bordered` : des cases tracées, comme un
+     * agenda papier. `minimal` : aucune bordure intérieure, les jours se
+     * lisent à leur numéro. `soft` : des cases sur fond teinté, séparées par
+     * des blancs.
+     */
+    variant?: "bordered" | "minimal" | "soft";
+    /** Le rendu des événements : fond léger, plein, ou contour. */
+    eventVariant?: "soft" | "solid" | "outline";
+    /** `compact` resserre les cases et la grille horaire. */
+    density?: "comfortable" | "compact";
+    /** L'heure affichée en haut de la grille horaire à l'ouverture. 8 h par défaut. */
+    scrollToHour?: number;
+    /** Un jour de la période affichée (`2026-09-30`). Aujourd'hui par défaut. */
+    date?: string;
+    defaultDate?: string;
+    onDateChange?: (date: string) => void;
+    /** @deprecated Ancien nom de `defaultDate`. */
+    defaultValue?: string;
+    /** @deprecated Ancien nom de `defaultDate`, au mois près. */
+    defaultMonth?: string;
+    /**
+     * La période visible, bornes incluses, à chaque changement de vue ou de
+     * période — et au premier affichage. C'est elle qu'on demande au serveur.
+     */
+    onRangeChange?: (range: {
+        start: string;
+        end: string;
+    }, view: CalendarView) => void;
+    /**
+     * Un clic sur un jour, hors événement : le moment de créer. Dans la
+     * grille horaire, `time` donne la demi-heure visée (`14:30`).
+     */
+    onDateClick?: (date: string, time?: string) => void;
+    onEventClick?: (event: T) => void;
+    /** Événements visibles par case en vue mois ; le reste passe dans « +N ». */
     maxEventsPerDay?: number;
-    onEventClick?: (event: CalendarEvent) => void;
+    firstDayOfWeek?: 0 | 1;
+    /** La langue des dates. Par défaut, celle de la locale SIA. */
+    locale?: string;
+    /** Remplace le contenu d'un événement. Le bouton qui l'entoure reste. */
+    renderEvent?: (event: T, placement: DayEvent<T & CalendarEventInput>) => ReactNode;
+    /** Actions à droite de la barre : « Nouvel événement », un filtre. */
+    toolbarActions?: ReactNode;
+    loading?: boolean;
+    /** Remplace, clé par clé, les textes du groupe `eventCalendar` de la locale. */
+    labels?: Partial<EventCalendarLabels>;
+    /** Le bouton « Aujourd'hui ». */
+    toolbarButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+    /** Le sélecteur de vue — un `RadioGroup` en boutons. */
+    viewSwitchProps?: Partial<Omit<RadioGroupProps, "value" | "defaultValue" | "onValueChange" | "children">>;
+    /** Chaque bouton de vue. */
+    viewButtonProps?: Partial<Omit<RadioButtonProps, "value" | "children">>;
+    /** Le bouton « +N autres » d'une case chargée. */
+    moreButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+    /** L'agenda vide. */
+    emptyStateProps?: Partial<EmptyStateProps>;
+    /** Le témoin de chargement de la barre. */
+    spinnerProps?: Partial<Omit<SpinnerProps, "label">>;
+    /** Les flèches de période. */
+    navButtonProps?: Partial<Omit<IconButtonProps, "onClick" | "label" | "icon">>;
+    /** La liste complète d'un jour chargé (« +N autres »). */
+    popoverProps?: Partial<Omit<PopoverProps, "content" | "children">>;
+    className?: string;
 }
 /**
- * Un calendrier qui porte des événements.
+ * Un calendrier d'événements : mois, semaine, agenda.
  *
- * `maxEventsPerDay` plafonne l'affichage : une journée à douze rendez-vous
- * déformerait toute la grille, et les douze ne se lisent de toute façon pas
- * dans une case de calendrier.
+ * Il affiche et signale ; il ne gère pas. Un clic sur un jour appelle
+ * `onDateClick`, un clic sur un événement `onEventClick` — `EventManager`
+ * s'y branche pour créer, consulter, modifier et supprimer. Les données
+ * viennent du serveur : `onRangeChange` donne la période à charger.
+ *
+ * Étroit, la grille du mois n'affiche plus que des points de couleur, et les
+ * événements du jour choisi s'affichent dessous : une case de 45 px ne se lit
+ * pas, une liste si.
  */
-declare function EventCalendar({ events, maxEventsPerDay, onEventClick, ...props }: EventCalendarProps): react_jsx_runtime.JSX.Element;
+declare function EventCalendar<T extends CalendarEvent = CalendarEvent>({ events, view: viewProp, defaultView, onViewChange, views, variant, eventVariant, density, scrollToHour, date: dateProp, defaultDate, defaultValue, defaultMonth, onDateChange, onRangeChange, onDateClick, onEventClick, maxEventsPerDay, firstDayOfWeek, locale: localeProp, renderEvent, toolbarActions, loading, labels: labelsProp, toolbarButtonProps, viewSwitchProps, viewButtonProps, moreButtonProps, emptyStateProps, spinnerProps, navButtonProps, popoverProps, className, }: EventCalendarProps<T>): react_jsx_runtime.JSX.Element;
 
-interface FiltersBarProps {
-    search?: ReactNode;
-    filters?: ReactNode;
-    actions?: ReactNode;
-    activeCount?: number;
-    onReset?: () => void;
-    resetLabel?: string;
+/** Ce que le formulaire rend : un événement prêt à envoyer, champs métier compris. */
+interface EventDraft {
+    title: string;
+    start: string;
+    end?: string | undefined;
+    allDay: boolean;
+    tone?: ComponentTone | undefined;
+    location?: string | undefined;
+    description?: string | undefined;
+    /** Les champs déclarés dans `extraFields`, sous leur nom. */
+    [champ: string]: unknown;
+}
+type Resultat = FormSubmitResult<FormShape> | Promise<FormSubmitResult<FormShape>>;
+/** Les libellés du gestionnaire : le groupe `eventManager` de la locale SIA. */
+type EventManagerLabels = EventManagerMessages;
+interface EventManagerProps<T extends CalendarEvent = CalendarEvent> {
+    events: T[];
+    /** Absent : pas de création. Rendre `{ champ: message }` garde le formulaire ouvert. */
+    onCreate?: (draft: EventDraft) => Resultat;
+    /** Absent : les événements se consultent sans se modifier. */
+    onUpdate?: (event: T, draft: EventDraft) => Resultat;
+    /** Absent : pas de suppression. Confirmée d'office. */
+    onDelete?: (event: T) => void | Promise<void>;
+    /** Des champs métier en plus : participants, salle, rappel. Leurs valeurs arrivent dans le brouillon. */
+    extraFields?: FormEntry[];
+    /** Les valeurs de départ de ces champs, et comment les relire sur un événement. */
+    extraDefaults?: FormShape;
+    /** Les couleurs proposées. Par défaut, les tons du système, nommés par la locale. */
+    toneOptions?: Array<{
+        value: ComponentTone;
+        label: string;
+    }>;
+    /** Remplace le contenu de la fiche d'un événement. */
+    renderDetail?: (event: T) => ReactNode;
+    /** Remplace, clé par clé, les textes du groupe `eventManager` de la locale. */
+    labels?: Partial<EventManagerLabels>;
+    /** La langue des dates de la fiche. Par défaut, celle de la locale SIA. */
+    locale?: string;
+    /** Le calendrier lui-même : vues, variantes, période, rendu des événements. */
+    calendarProps?: Partial<Omit<EventCalendarProps<T>, "events" | "onDateClick" | "onEventClick">>;
+    /** Les boîtes de fiche et de formulaire. */
+    modalProps?: Partial<Omit<ModalProps, "open" | "onOpenChange" | "children" | "title" | "footer">>;
+    /** Le formulaire, hors champs, valeurs et envoi qu'il reçoit d'ici. */
+    formProps?: Partial<Omit<FormProps, "fields" | "form" | "defaultValues" | "validate" | "onSubmit">>;
+    /** La confirmation de suppression. */
+    confirmDialogProps?: Partial<Omit<ConfirmDialogProps, "open" | "onOpenChange" | "onConfirm">>;
+    /** Le bouton « Nouvel événement » de la barre. */
+    createButtonProps?: Partial<Omit<ButtonProps, "onClick">>;
+    /** La fiche d'un événement, hors rubriques qu'elle tire de l'événement. */
+    descriptionsProps?: Partial<Omit<DescriptionsProps, "items">>;
+    /** La pastille d'une couleur, dans la fiche et dans le choix des couleurs. */
+    toneBadgeProps?: Partial<Omit<BadgeProps, "tone" | "children">>;
     className?: string;
 }
 /**
- * La barre au-dessus d'une liste : recherche, filtres, actions.
+ * Un calendrier où l'on gère ses événements.
  *
- * `activeCount` affiche combien de filtres sont en vigueur. Sans ce compte,
- * une liste filtrée ressemble à une liste vide, et l'on cherche la panne
- * avant de penser au filtre posé la veille.
+ * Il assemble ce qui existe — \`EventCalendar\` pour voir, \`Modal\` et
+ * \`Form\` pour saisir, \`ConfirmDialog\` pour supprimer — et tient le reste :
+ *
+ * - un clic sur un jour ouvre la création à cette date, et à la demi-heure
+ *   visée dans la grille horaire ;
+ * - un clic sur un événement ouvre sa fiche, d'où l'on modifie ou supprime ;
+ * - un refus du serveur garde le formulaire ouvert, erreurs sous les champs.
+ *
+ * Les données restent à l'appelant : `onCreate`, `onUpdate` et `onDelete`
+ * reçoivent un brouillon prêt à envoyer, et le calendrier affiche ce qu'on
+ * lui repasse dans `events`.
  */
-declare function FiltersBar({ search, filters, actions, activeCount, onReset, resetLabel: resetLabelProp, className }: FiltersBarProps): react_jsx_runtime.JSX.Element;
+declare function EventManager<T extends CalendarEvent = CalendarEvent>({ events, onCreate, onUpdate, onDelete, extraFields, extraDefaults, toneOptions: toneOptionsProp, renderDetail, labels: labelsProp, locale: localeProp, calendarProps, modalProps, formProps, confirmDialogProps, createButtonProps, descriptionsProps, toneBadgeProps, className, }: EventManagerProps<T>): react_jsx_runtime.JSX.Element;
 
 interface HoverCardProps {
     content: ReactNode;
@@ -2756,6 +3585,8 @@ interface HoverCardProps {
     /** Délai avant fermeture, le temps d'atteindre le panneau à la souris. */
     closeDelay?: number;
     placement?: OverlayPlacement;
+    /** Réglages du panneau flottant — décalage, marge au bord, rôle, classe. */
+    overlayProps?: Partial<Omit<OverlayProps, "open" | "anchorRef" | "onOpenChange" | "children">>;
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
     width?: number | string;
@@ -2768,25 +3599,7 @@ interface HoverCardProps {
  * d'œil, celui-là porte du contenu — une fiche, un résumé, une image — que
  * l'on peut vouloir survoler à son tour, voire sélectionner.
  */
-declare function HoverCard({ content, children, openDelay, closeDelay, placement, open: openProp, onOpenChange, width, className, }: HoverCardProps): react_jsx_runtime.JSX.Element;
-
-interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    label: string;
-    icon: ReactNode;
-    variant?: "solid" | "outline" | "ghost";
-    size?: "sm" | "md" | "lg";
-    radius?: "default" | "none" | "sm" | "lg" | "full";
-    tooltip?: Omit<TooltipProps, "children">;
-}
-/**
- * Une action réduite à son icône.
- *
- * `label` est obligatoire : une icône seule n'a pas de nom, et un lecteur
- * d'écran annoncerait « bouton » sans dire lequel. Le libellé sert aussi
- * d'infobulle — ce que l'icône signifie doit rester atteignable à la
- * souris comme au clavier.
- */
-declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare function HoverCard({ content, children, openDelay, closeDelay, placement, overlayProps, open: openProp, onOpenChange, width, className, }: HoverCardProps): react_jsx_runtime.JSX.Element;
 
 type IconProps = SVGProps<SVGSVGElement>;
 declare function CalendarIcon(props: IconProps): react_jsx_runtime.JSX.Element;
@@ -2820,6 +3633,8 @@ declare function KeyIcon(props: IconProps): react_jsx_runtime.JSX.Element;
 declare function LockIcon(props: IconProps): react_jsx_runtime.JSX.Element;
 declare function LogOutIcon(props: IconProps): react_jsx_runtime.JSX.Element;
 declare function PencilIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function SunIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function MoonIcon(props: IconProps): react_jsx_runtime.JSX.Element;
 
 interface InputNumberProps extends Omit<InputProps, "value" | "defaultValue" | "onChange" | "type" | "right"> {
     value?: number | null;
@@ -2845,6 +3660,200 @@ interface InputNumberProps extends Omit<InputProps, "value" | "defaultValue" | "
  */
 declare const InputNumber: react.ForwardRefExoticComponent<InputNumberProps & react.RefAttributes<HTMLInputElement>>;
 
+interface ProgressProps {
+    /** La valeur courante. Omise, la barre passe en indéterminé. */
+    value?: number | undefined;
+    max?: number;
+    shape?: "bar" | "circle";
+    tone?: ComponentTone;
+    size?: ComponentSize;
+    /** Épaisseur du trait, en pixels. Par défaut selon la taille. */
+    thickness?: number | undefined;
+    /** Affiche le pourcentage — au centre du cercle, en bout de barre. */
+    showValue?: boolean;
+    /** Remplace l'affichage par défaut. */
+    format?: ((percent: number, value: number, max: number) => ReactNode) | undefined;
+    label?: ReactNode;
+    className?: string;
+}
+/**
+ * L'avancement d'une tâche.
+ *
+ * Sans `value`, le composant passe en indéterminé plutôt que d'afficher zéro :
+ * « je travaille » et « je n'ai rien fait » ne se ressemblent pas.
+ */
+declare function Progress(props: ProgressProps): react_jsx_runtime.JSX.Element;
+
+type StepStatus = "done" | "current" | "upcoming" | "error";
+interface StepItem {
+    key: string;
+    title: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    /** Forcé au besoin; sinon déduit de `current`. */
+    status?: StepStatus;
+    disabled?: boolean;
+}
+interface StepsProps {
+    items: StepItem[];
+    /** Index de l'étape en cours. Ce qui précède est fait, ce qui suit à venir. */
+    current?: number;
+    orientation?: "horizontal" | "vertical";
+    size?: "sm" | "md";
+    /** Rend les étapes cliquables — pour revenir en arrière dans un tunnel. */
+    onStepClick?: (item: StepItem, index: number) => void;
+    className?: string;
+}
+/**
+ * Une progression en étapes.
+ *
+ * Le trait entre deux étapes se remplit plutôt que de changer de couleur d'un
+ * coup : c'est ce qui donne le sens de la marche, vers l'avant.
+ */
+declare function Steps({ items, current, orientation, size, onStepClick, className, }: StepsProps): react_jsx_runtime.JSX.Element;
+
+/** Le cycle de vie d'une opération asynchrone. */
+type JobStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
+/** Un instant : une date ISO, un horodatage ou une `Date`. */
+type JobInstant = string | number | Date;
+/**
+ * Les textes du composant, à remplacer au cas par cas. Leur valeur par défaut
+ * vient du groupe `jobProgress` de la locale (`JobProgressMessages`) ; ici,
+ * un texte peut aussi être un nœud, et `attempts` une fonction.
+ */
+interface JobProgressLabels {
+    queued: ReactNode;
+    running: ReactNode;
+    succeeded: ReactNode;
+    failed: ReactNode;
+    cancelled: ReactNode;
+    /** « Essai 2 sur 3 », ou « Essai 2 » sans maximum connu. */
+    attempts: (current: number, max?: number) => ReactNode;
+    /** Le titre de l'encadré d'erreur. */
+    errorTitle: ReactNode;
+    retry: ReactNode;
+    cancel: ReactNode;
+}
+interface JobProgressProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    status: JobStatus;
+    /** L'avancement, de 0 à 100. Absent pendant `queued`/`running` : indéterminé. */
+    progress?: number;
+    /** L'étape en cours : « Construction de l'image ». */
+    step?: ReactNode;
+    /** Les étapes de l'opération, affichées en liste ; `currentStep` la met en avant. */
+    steps?: StepItem[];
+    /** L'index de l'étape en cours dans `steps`. */
+    currentStep?: number;
+    /** L'essai en cours, et le nombre maximal quand il est connu. */
+    attempts?: {
+        current: number;
+        max?: number;
+    };
+    startedAt?: JobInstant;
+    /** Absent pendant `running` : la durée avance chaque seconde. */
+    finishedAt?: JobInstant;
+    /** Le message d'échec, affiché quand `status` vaut `failed`. */
+    error?: ReactNode;
+    /** Affiche « Relancer » quand l'opération a échoué. */
+    onRetry?: () => void;
+    /** Affiche « Annuler » tant que l'opération est en file ou en cours. */
+    onCancel?: () => void;
+    /** Un emplacement libre sous le reste : un journal, une sortie de commande. */
+    logs?: ReactNode;
+    title?: ReactNode;
+    labels?: Partial<JobProgressLabels>;
+    /** Le ton de chaque statut, pour la pastille et la barre. */
+    statusTones?: Partial<Record<JobStatus, ComponentTone>>;
+    /** Les props de la pastille de statut. Sans `value`, `tones` ni `labels`, tirés du statut. */
+    statusBadgeProps?: Partial<Omit<StatusBadgeProps, "value" | "tones" | "labels">>;
+    /** Les props de la barre. Sans `value`, tirée de `progress`. */
+    progressProps?: Partial<Omit<ProgressProps, "value">>;
+    /** Les props de la liste d'étapes. Sans `items` ni `current`. */
+    stepsProps?: Partial<Omit<StepsProps, "items" | "current">>;
+    /** Les props de la durée. Sans `milliseconds`, calculée des deux instants. */
+    durationProps?: Partial<Omit<DurationDisplayProps, "milliseconds">>;
+    /** Les props de l'encadré d'erreur. Sans `children`, qui est `error`. */
+    alertProps?: Partial<Omit<AlertProps, "children">>;
+    /** Les props du bouton « Relancer ». Sans `onClick`, qui est `onRetry`. */
+    retryButtonProps?: Partial<Omit<ButtonProps, "onClick">>;
+    /** Les props du bouton « Annuler ». Sans `onClick`, qui est `onCancel`. */
+    cancelButtonProps?: Partial<Omit<ButtonProps, "onClick">>;
+}
+/**
+ * Le suivi d'une opération asynchrone : un déploiement, un import, un export.
+ *
+ * Statut, étape, progression, essais, erreur et relance : chaque projet
+ * recomposait ce motif avec les mêmes briques, et chacun oubliait une chose
+ * différente — la durée figée pendant l'exécution, le bouton d'annulation
+ * resté visible après l'échec. Le composant tranche ce qui s'affiche selon le
+ * statut ; l'appelant ne fournit que l'état de l'opération.
+ *
+ * Pensé pour un tiroir de 28 à 40rem : dense, sur une colonne.
+ */
+declare function JobProgress({ status, progress, step, steps, currentStep, attempts, startedAt, finishedAt, error, onRetry, onCancel, logs, title, labels: labelsProp, statusTones, statusBadgeProps, progressProps, stepsProps, durationProps, alertProps, retryButtonProps, cancelButtonProps, className, ...props }: JobProgressProps): react_jsx_runtime.JSX.Element;
+
+interface ScrollAreaProps {
+    children: ReactNode;
+    /** Hauteur maximale. Au-delà, la zone défile. */
+    maxHeight?: number | string;
+    height?: number | string;
+    orientation?: "vertical" | "horizontal" | "both";
+    /**
+     * Estompe le contenu aux bords tant qu'il reste quelque chose à faire
+     * défiler. C'est le seul indice fiable quand la barre est fine ou masquée.
+     */
+    fade?: boolean;
+    className?: string;
+}
+/**
+ * Une zone défilante sobre.
+ *
+ * La barre reste celle du navigateur, seulement affinée : une barre
+ * réimplémentée en JavaScript coûte un écouteur de défilement, deux mesures
+ * par image et perd le défilement inertiel des pavés tactiles. Le seul ajout
+ * est l'estompe des bords, qui ne demande qu'un booléen par côté.
+ */
+declare function ScrollArea({ children, maxHeight, height, orientation, fade, className, }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
+
+interface JsonViewProps {
+    /** Une valeur déjà analysée : objet, tableau, scalaire. */
+    value?: unknown;
+    /**
+     * Un texte JSON, analysé ici. S'il est invalide, il s'affiche tel quel
+     * sous une alerte discrète : une réponse serveur tronquée reste lisible.
+     * Prioritaire sur `value`.
+     */
+    source?: string;
+    /** Les niveaux ouverts au premier affichage. `2` par défaut. */
+    defaultExpandDepth?: number;
+    /** Faux : un simple bloc mis en forme, tout ouvert, sans bascule. */
+    collapsible?: boolean;
+    /** Au-delà, la zone défile. */
+    maxHeight?: number | string;
+    /** Vrai par défaut : un bouton copie le JSON mis en forme. */
+    copyable?: boolean;
+    copyLabel?: string;
+    copiedLabel?: string;
+    /** Le titre de l'alerte quand `source` ne s'analyse pas. */
+    invalidLabel?: ReactNode;
+    className?: string;
+    /** Le bouton de copie. Son action et son libellé suivent la copie. */
+    copyButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+    /** L'alerte d'un texte invalide. Son contenu est l'erreur d'analyse. */
+    alertProps?: Partial<Omit<AlertProps, "children">>;
+    /** La zone défilante. Sa hauteur maximale passe par `maxHeight`. */
+    scrollAreaProps?: Partial<Omit<ScrollAreaProps, "children" | "maxHeight">>;
+}
+/**
+ * Un JSON en lecture seule, que l'on déplie.
+ *
+ * Pour une réponse d'API, une charge utile, une configuration : les types se
+ * distinguent à la couleur, les branches profondes restent repliées, et un
+ * nœud replié dit ce qu'il contient — `{…} 3 clés`. À la différence de
+ * `JsonEditor`, rien ne s'y saisit.
+ */
+declare function JsonView({ value, source, defaultExpandDepth, collapsible, maxHeight, copyable, copyLabel: copyLabelProp, copiedLabel: copiedLabelProp, invalidLabel: invalidLabelProp, className, copyButtonProps, alertProps, scrollAreaProps, }: JsonViewProps): react_jsx_runtime.JSX.Element;
+
 interface KpiGridProps extends HTMLAttributes<HTMLDivElement> {
     columns?: 1 | 2 | 3 | 4;
 }
@@ -2876,132 +3885,197 @@ type ILabelProps = LabelProps;
  */
 declare const Label: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLLabelElement>>;
 
+type LiveStatus = "connecting" | "open" | "closed";
+interface LiveIndicatorProps extends Omit<HTMLAttributes<HTMLSpanElement>, "children"> {
+    /** L'état de la connexion — `useRealtimeStatus(source)` le fournit. */
+    status: LiveStatus;
+    /** Les libellés de chaque état. Par défaut, ceux de la locale. */
+    labels?: Partial<Record<LiveStatus, string>>;
+    /** Le point seul, le libellé restant pour les lecteurs d'écran. */
+    compact?: boolean;
+}
 /**
- * Le même calendrier, en plus petit.
+ * Dit si l'écran se met à jour tout seul.
  *
- * Une variante de taille et non un composant à part : deux calendriers
- * séparés auraient divergé sur la sélection de plage, les jours désactivés
- * ou le premier jour de la semaine.
+ * Sans lui, une liste qui ne bouge plus après une coupure réseau ressemble à
+ * une liste à jour. Le point pulse en direct, clignote en connexion, s'éteint
+ * hors ligne ; le libellé est annoncé quand il change.
  */
-declare function MiniCalendar({ className, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare function LiveIndicator({ status, labels, compact, className, ...props }: LiveIndicatorProps): react_jsx_runtime.JSX.Element;
 
-interface ModalProps {
-    open: boolean;
-    onOpenChange: (open: boolean) => void;
-    title: ReactNode;
-    description?: ReactNode;
+interface ToggleProps {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
     children?: ReactNode;
-    footer?: ReactNode;
-    closeOnBackdrop?: boolean;
-    closeLabel?: string;
+    icon?: ReactNode;
+    /** Obligatoire quand le contenu se réduit à une icône. */
+    ariaLabel?: string;
+    size?: ComponentSize;
+    tone?: ComponentTone;
+    variant?: "solid" | "outline" | "ghost";
+    disabled?: boolean;
     className?: string;
 }
 /**
- * Une boîte qui interrompt.
+ * Un bouton à deux états.
  *
- * Elle enferme le focus et bloque le défilement de la page : sans cela, la
- * tabulation continue derrière le voile, et l'on remplit un formulaire
- * qu'on ne voit pas. L'échappement la referme toujours — c'est la sortie
- * que tout le monde essaie en premier.
+ * Ce n'est pas un `Switch` : un interrupteur décrit un réglage qui persiste,
+ * une bascule décrit un état de l'interface ici et maintenant — gras, filtre
+ * actif, colonne affichée. `aria-pressed` porte cette différence.
  */
-declare function Modal({ open, onOpenChange, title, description, children, footer, closeOnBackdrop, closeLabel: closeLabelProp, className }: ModalProps): react.ReactPortal | null;
-
-interface MonthPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
-    onValueChange?: (value: string) => void;
-    invalid?: boolean;
+declare function Toggle({ pressed: pressedProp, defaultPressed, onPressedChange, children, icon, ariaLabel, size, tone, variant, disabled, className, }: ToggleProps): react_jsx_runtime.JSX.Element;
+interface ToggleGroupOption {
+    value: string;
+    label?: ReactNode;
+    icon?: ReactNode;
+    ariaLabel?: string;
+    disabled?: boolean;
 }
-/**
- * Un mois, sans le jour.
- *
- * C'est le grain d'un exercice comptable ou d'un rapport mensuel : demander
- * un jour obligerait à en choisir un arbitrairement, et le premier du mois
- * finirait par être pris pour une vraie date.
- */
-declare const MonthPicker: react.ForwardRefExoticComponent<MonthPickerProps & react.RefAttributes<HTMLInputElement>>;
-
-interface PageHeaderProps {
-    title: ReactNode;
-    description?: ReactNode;
-    eyebrow?: ReactNode;
-    actions?: ReactNode;
-    /**
-     * Le niveau du titre. `1` — le défaut — pour l'en-tête d'un écran.
-     *
-     * `2` ou `3` pour une section dans un écran qui a déjà son `<h1>` : la
-     * liste des environnements dans la fiche d'un projet. Le titre y est plus
-     * petit et l'espace sous l'en-tête plus court.
-     */
-    level?: 1 | 2 | 3;
+interface ToggleGroupProps {
+    options: ToggleGroupOption[];
+    /** `single` : une valeur ou aucune. `multiple` : un tableau. */
+    type?: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    /** Une chaîne en `single`, un tableau en `multiple` — comme `value`. */
+    onValueChange?: (value: string | string[]) => void;
+    size?: ComponentSize;
+    tone?: ComponentTone;
+    /** Autorise à tout désélectionner en `single`. */
+    deselectable?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
     className?: string;
 }
 /**
- * Le titre d'un écran, et ses actions.
+ * Plusieurs bascules qui partagent une valeur.
  *
- * Un seul `<h1>` par page, rendu ici : la hiérarchie des titres est ce qui
- * permet de parcourir un écran au lecteur d'écran, et deux `<h1>` la
- * cassent sans que rien ne se voie. Une section imbriquée passe donc
- * `level={2}`.
+ * Le repère glisse d'une option à l'autre au lieu de sauter : c'est la même
+ * idée que les onglets, et c'est ce qui rend le changement lisible.
  */
-declare function PageHeader({ title, description, eyebrow, actions, level, className, }: PageHeaderProps): react_jsx_runtime.JSX.Element;
+declare function ToggleGroup({ options, type, value: valueProp, defaultValue, onValueChange, size, tone, deselectable, disabled, ariaLabel, className, }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
 
-interface PaginationProps {
-    page: number;
-    totalPages: number;
-    onPageChange: (page: number) => void;
-    siblingCount?: number;
-    previousLabel?: string;
-    nextLabel?: string;
+/** La gravité d'une ligne. */
+type LogLevel = "debug" | "info" | "warn" | "error" | "success";
+/** Une ligne de journal. */
+interface LogLine {
     /**
-     * Ajoute un champ pour sauter directement à une page.
-     *
-     * Sur quarante pages, atteindre la vingt-septième demande sinon de cliquer
-     * dans les ellipses jusqu'à ce qu'elle apparaisse.
+     * Un identifiant stable. Facultatif, mais conseillé : sans lui, la ligne
+     * est repérée par sa position, et un tableau raccourci par le début
+     * obligerait à redessiner toutes les lignes.
      */
-    jumpTo?: boolean;
-    /** Affiche « Page 3 sur 40 » à côté des numéros. */
-    showTotal?: boolean;
-    /** Masque les libellés et ne garde que les flèches. */
-    compact?: boolean;
-    /** Le nombre de lignes par page en vigueur. */
-    pageSize?: number;
+    id?: string;
+    /** Quand : une date ISO, un horodatage ou une `Date`. */
+    time: string | number | Date;
+    level: LogLevel;
+    message: ReactNode;
+    /** L'essai, l'étape ou la tâche : « Essai 1 », « Essai 2 ». */
+    group?: string;
+}
+interface LogStreamProps {
+    lines: LogLine[];
     /**
-     * Fourni avec `pageSize`, ajoute le choix du nombre de lignes par page.
+     * Le nombre de lignes gardées. Au-delà, les plus anciennes tombent.
      *
-     * Seul le nouveau nombre est remonté : revenir en page 1 est l'affaire de
-     * qui tient l'état — `setPerPage` de `useTableQuery` le fait déjà.
+     * C'est la réponse à un journal qui grossit sans fin, plutôt qu'une
+     * virtualisation : mille lignes se dessinent sans peine, et une liste
+     * virtuelle casserait la recherche du navigateur et la sélection au
+     * clavier. `1000` par défaut.
      */
-    onPageSizeChange?: (pageSize: number) => void;
-    /**
-     * Les tailles proposées. Par défaut `10, 20, 50, 100`. Une taille en
-     * vigueur absente de la liste y est ajoutée, pour que le champ ne paraisse
-     * jamais vide.
-     */
-    pageSizeOptions?: number[];
-    /** Le libellé du choix. Par défaut `locale.perPage` — « Par page ». */
-    pageSizeLabel?: string;
+    maxLines?: number;
+    /** La hauteur de la zone défilante. `20rem` par défaut. */
+    height?: number | string;
     /**
-     * Remplace entièrement le contrôle — des boutons segmentés, un champ libre.
-     * Le choix des tailles et leur tri sont déjà faits.
+     * Défiler jusqu'à la dernière ligne à chaque arrivée. Contrôlé quand il
+     * est fourni ; remonter dans le journal appelle alors `onFollowChange(false)`.
      */
-    renderPageSize?: (context: PageSizeContext) => ReactNode;
+    follow?: boolean;
+    /** Vrai par défaut : un journal d'exécution se lit par la fin. */
+    defaultFollow?: boolean;
+    onFollowChange?: (follow: boolean) => void;
+    /** Les niveaux affichés. Contrôlé quand il est fourni. */
+    levels?: LogLevel[];
+    /** Tous par défaut. */
+    defaultLevels?: LogLevel[];
+    onLevelsChange?: (levels: LogLevel[]) => void;
+    /** Les libellés des niveaux, dans la colonne comme dans la copie. */
+    levelLabels?: Partial<Record<LogLevel, string>>;
+    /** Les groupes repliés au premier affichage. */
+    defaultCollapsedGroups?: string[];
+    /** Le premier chargement : rien n'est encore arrivé. */
+    loading?: boolean;
+    /** Des lignes arrivent encore. Un indicateur discret le dit. */
+    streaming?: boolean;
+    streamingLabel?: string;
+    loadingLabel?: string;
+    /** La langue du format horaire. Par défaut, celle de la locale SIA. */
+    locale?: string;
+    /** Sans barre d'outils : ni filtre, ni recherche, ni copie. */
+    toolbar?: boolean;
+    /** Le nom de la zone pour les lecteurs d'écran. */
     ariaLabel?: string;
+    searchPlaceholder?: string;
+    copyLabel?: string;
+    copiedLabel?: string;
+    followLabel?: string;
+    resumeLabel?: string;
     className?: string;
+    /**
+     * Le filtre par niveau. Sans ses options ni sa valeur, tirées des niveaux,
+     * ni son type : on en retient plusieurs à la fois.
+     */
+    levelFilterProps?: Partial<Omit<ToggleGroupProps, "options" | "type" | "value" | "defaultValue" | "onValueChange">>;
+    /** La recherche. Sa valeur reste celle du journal, qui filtre avec. */
+    searchInputProps?: Partial<Omit<SearchInputProps, "value" | "defaultValue" | "onValueChange">>;
+    /** Le bouton de copie. Son action et son libellé suivent la copie. */
+    copyButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+    /** La bascule « Suivre la fin ». Son état est celui du suivi. */
+    followToggleProps?: Partial<Omit<ToggleProps, "pressed" | "defaultPressed" | "onPressedChange">>;
+    /** Le bouton « Reprendre le suivi », affiché quand le suivi est en pause. */
+    resumeButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children">>;
+    /**
+     * L'en-tête repliable de chaque groupe. `aria-expanded` et
+     * `aria-controls` restent calculés groupe par groupe.
+     */
+    groupButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children" | "aria-expanded" | "aria-controls">>;
+    /** L'état vide : pas encore de ligne, ou aucune qui corresponde. */
+    emptyStateProps?: Partial<EmptyStateProps>;
+    /** Les indicateurs de chargement et de flux en cours. Sans `label`. */
+    spinnerProps?: Partial<Omit<SpinnerProps, "label">>;
 }
-/** Ce que reçoit `renderPageSize`. */
-interface PageSizeContext {
-    pageSize: number;
-    options: number[];
-    onChange: (pageSize: number) => void;
-    label: string;
-}
-declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
 /**
- * La navigation entre les pages.
+ * Un journal d'exécution qui se lit en direct.
  *
- * Le calcul des numéros et des ellipses vient de `@sia-ui/headless` :
- * `usePagination` et ce composant appliquent la même règle, écrite une fois.
+ * `Timeline` raconte des événements ; ici, on suit une exécution : heure en
+ * colonne, niveau, police à chasse fixe, essais repliables. Le suivi de la
+ * fin se met en pause dès qu'on remonte — lire une erreur pendant que le
+ * journal défile sous les yeux est impossible — et un bouton dit combien de
+ * lignes sont arrivées entre-temps.
+ */
+declare function LogStream({ lines, maxLines, height, follow, defaultFollow, onFollowChange, levels: levelsProp, defaultLevels, onLevelsChange, levelLabels, defaultCollapsedGroups, loading, streaming, streamingLabel: streamingLabelProp, loadingLabel: loadingLabelProp, locale: localeProp, toolbar, ariaLabel: ariaLabelProp, searchPlaceholder: searchPlaceholderProp, copyLabel: copyLabelProp, copiedLabel: copiedLabelProp, followLabel: followLabelProp, resumeLabel: resumeLabelProp, className, levelFilterProps, searchInputProps, copyButtonProps, followToggleProps, resumeButtonProps, groupButtonProps, emptyStateProps, spinnerProps, }: LogStreamProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Le même calendrier, en plus petit.
+ *
+ * Une variante de taille et non un composant à part : deux calendriers
+ * séparés auraient divergé sur la sélection de plage, les jours désactivés
+ * ou le premier jour de la semaine.
  */
-declare function Pagination({ page, totalPages, onPageChange, siblingCount, previousLabel: previousLabelProp, nextLabel: nextLabelProp, jumpTo, showTotal, compact, pageSize, onPageSizeChange, pageSizeOptions, pageSizeLabel, renderPageSize, ariaLabel, className, }: PaginationProps): react_jsx_runtime.JSX.Element | null;
+declare function MiniCalendar({ className, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+
+interface MonthPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    onValueChange?: (value: string) => void;
+    invalid?: boolean;
+}
+/**
+ * Un mois, sans le jour.
+ *
+ * C'est le grain d'un exercice comptable ou d'un rapport mensuel : demander
+ * un jour obligerait à en choisir un arbitrairement, et le premier du mois
+ * finirait par être pris pour une vraie date.
+ */
+declare const MonthPicker: react.ForwardRefExoticComponent<MonthPickerProps & react.RefAttributes<HTMLInputElement>>;
 
 interface PasswordStrength {
     /** De 0 à 4. */
@@ -3015,7 +4089,8 @@ interface PasswordInputProps extends Omit<InputProps, "type" | "right"> {
     hideToggle?: boolean;
     /**
      * Remplace l'évaluation par défaut. Un projet qui utilise `zxcvbn` branche
-     * son résultat ici; le composant ne dépend de rien.
+     * son résultat ici; le composant ne dépend de rien. Les libellés de
+     * l'évaluation par défaut viennent de la locale (`passwordInput`).
      */
     evaluate?: (value: string) => PasswordStrength;
 }
@@ -3048,7 +4123,11 @@ interface PhoneCountry {
     code: string;
     /** Indicatif, avec le `+`. */
     dial: string;
-    label: string;
+    /**
+     * Le nom affiché. Par défaut, celui que donne `Intl.DisplayNames` dans la
+     * langue de la locale — « Cameroun », « Cameroon ».
+     */
+    label?: string;
     flag: string;
     /** Nombre de chiffres attendus après l'indicatif. */
     digits?: number;
@@ -3074,6 +4153,14 @@ interface PhoneInputProps extends Omit<InputProps, "value" | "defaultValue" | "o
     defaultCountry?: string;
     /** Verrouille le pays et masque le sélecteur. */
     lockCountry?: boolean;
+    /**
+     * Le sélecteur d'indicatif : placement, recherche, rendu, classe.
+     *
+     * La valeur, les options et le rappel viennent de `countries` et du
+     * numéro ; `disabled` suit celui du champ — pour figer le pays seul,
+     * `lockCountry`.
+     */
+    countrySelectProps?: Partial<Omit<SelectProps, "value" | "defaultValue" | "options" | "children" | "onValueChange" | "disabled">>;
 }
 /**
  * Un numéro de téléphone international.
@@ -3088,59 +4175,9 @@ interface PhoneInputProps extends Omit<InputProps, "value" | "defaultValue" | "o
  */
 declare const PhoneInput: react.ForwardRefExoticComponent<PhoneInputProps & react.RefAttributes<HTMLInputElement>>;
 
-interface PopoverProps {
-    content: ReactNode;
-    title?: ReactNode;
-    children: ReactElement<{
-        onClick?: () => void;
-        "aria-expanded"?: boolean;
-    }>;
-    open?: boolean;
-    defaultOpen?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    placement?: OverlayPlacement;
-    trigger?: "click" | "hover";
-    variant?: "solid" | "outline";
-    tone?: ComponentTone;
-    disabled?: boolean;
-    className?: string;
-}
-/**
- * Un panneau attaché à un élément, avec du contenu qu'on peut viser.
- *
- * À la différence d'une infobulle, il reste ouvert : on y met un lien, un
- * bouton, un petit formulaire. Une infobulle qui contient un bouton est une
- * infobulle cassée — elle disparaît dès qu'on va vers lui.
- */
-declare function Popover({ content, title, children, open: openProp, defaultOpen, onOpenChange, placement, trigger, variant, tone, disabled, className }: PopoverProps): react_jsx_runtime.JSX.Element;
-
-interface ProgressProps {
-    /** La valeur courante. Omise, la barre passe en indéterminé. */
-    value?: number | undefined;
-    max?: number;
-    shape?: "bar" | "circle";
-    tone?: ComponentTone;
-    size?: ComponentSize;
-    /** Épaisseur du trait, en pixels. Par défaut selon la taille. */
-    thickness?: number | undefined;
-    /** Affiche le pourcentage — au centre du cercle, en bout de barre. */
-    showValue?: boolean;
-    /** Remplace l'affichage par défaut. */
-    format?: ((percent: number, value: number, max: number) => ReactNode) | undefined;
-    label?: ReactNode;
-    className?: string;
-}
-/**
- * L'avancement d'une tâche.
- *
- * Sans `value`, le composant passe en indéterminé plutôt que d'afficher zéro :
- * « je travaille » et « je n'ai rien fait » ne se ressemblent pas.
- */
-declare function Progress(props: ProgressProps): react_jsx_runtime.JSX.Element;
-
 interface QRCodeProps {
     value: string;
-    size?: number;
+    size?: number; /** Par défaut, celui de la locale. */
     label?: string;
     render?: (value: string, size: number) => ReactNode;
     className?: string;
@@ -3152,10 +4189,11 @@ interface QRCodeProps {
  * dépendance à tous ceux qui ne s'en servent pas, alors que les projets qui
  * en ont besoin ont déjà le leur.
  */
-declare function QRCode({ value, size, label, render, className }: QRCodeProps): react_jsx_runtime.JSX.Element;
+declare function QRCode({ value, size, label: labelProp, render, className }: QRCodeProps): react_jsx_runtime.JSX.Element;
 
 interface RelativeTimeProps extends Omit<HTMLAttributes<HTMLTimeElement>, "dateTime"> {
     value: Date | string | number;
+    /** La langue de la phrase. Par défaut, celle de la locale SIA. */
     locale?: string;
     prefix?: string;
     refreshInterval?: number;
@@ -3166,7 +4204,7 @@ interface RelativeTimeProps extends Omit<HTMLAttributes<HTMLTimeElement>, "dateT
  * Elle se rafraîchit d'elle-même : « il y a une minute » affiché une heure
  * plus tard est faux, et rien ne le signale à qui lit l'écran resté ouvert.
  */
-declare function RelativeTime({ value, locale, prefix, refreshInterval, className, title, ...props }: RelativeTimeProps): react_jsx_runtime.JSX.Element | null;
+declare function RelativeTime({ value, locale: localeProp, prefix, refreshInterval, className, title, ...props }: RelativeTimeProps): react_jsx_runtime.JSX.Element | null;
 
 interface RequireSessionProps<TUser, TTenant, TRule> {
     session: SessionStore<TUser, TTenant, TRule>;
@@ -3198,18 +4236,23 @@ interface RequireSessionProps<TUser, TTenant, TRule> {
     onForbidden?: (state: SessionState<TUser, TTenant>) => void;
     onIncomplete?: (state: SessionState<TUser, TTenant>) => void;
     className?: string;
+    /**
+     * Les props du `Spinner` d'attente par défaut — taille, variante, libellé
+     * lu par les lecteurs d'écran. Sans effet quand `pending` est fourni.
+     */
+    spinnerProps?: Partial<SpinnerProps>;
 }
 /**
  * Ce qui se trouve derrière une session valide.
  *
- * Écrite cinq fois dans les projets du disque D, cinq fois de la même façon
- * à la cible de redirection près. Elle ne dépend d'aucun routeur : elle rend
+ * Chaque application l'écrit, presque toujours de la même façon, à la cible
+ * de redirection près. Elle ne dépend d'aucun routeur : elle rend
  * un état et prévient, l'application décide où aller.
  *
  * > Ceci protège l'interface, pas les données. Une route masquée reste une
  * > route ouverte tant que le serveur ne refuse pas l'appel.
  */
-declare function RequireSession<TUser, TTenant, TRule = PermissionRule>({ session, children, require: rule, pending, fallback, forbidden, allowIncomplete, onUnauthenticated, onForbidden, onIncomplete, className, }: RequireSessionProps<TUser, TTenant, TRule>): react_jsx_runtime.JSX.Element;
+declare function RequireSession<TUser, TTenant, TRule = PermissionRule>({ session, children, require: rule, pending, fallback, forbidden, allowIncomplete, onUnauthenticated, onForbidden, onIncomplete, className, spinnerProps, }: RequireSessionProps<TUser, TTenant, TRule>): react_jsx_runtime.JSX.Element;
 interface CanProps<TUser, TTenant, TRule> {
     session: SessionStore<TUser, TTenant, TRule>;
     require: TRule;
@@ -3243,57 +4286,6 @@ interface ResizablePanelProps {
  */
 declare function ResizablePanel({ first, second, defaultSize, minSize, maxSize, direction, className }: ResizablePanelProps): react_jsx_runtime.JSX.Element;
 
-interface ScrollAreaProps {
-    children: ReactNode;
-    /** Hauteur maximale. Au-delà, la zone défile. */
-    maxHeight?: number | string;
-    height?: number | string;
-    orientation?: "vertical" | "horizontal" | "both";
-    /**
-     * Estompe le contenu aux bords tant qu'il reste quelque chose à faire
-     * défiler. C'est le seul indice fiable quand la barre est fine ou masquée.
-     */
-    fade?: boolean;
-    className?: string;
-}
-/**
- * Une zone défilante sobre.
- *
- * La barre reste celle du navigateur, seulement affinée : une barre
- * réimplémentée en JavaScript coûte un écouteur de défilement, deux mesures
- * par image et perd le défilement inertiel des pavés tactiles. Le seul ajout
- * est l'estompe des bords, qui ne demande qu'un booléen par côté.
- */
-declare function ScrollArea({ children, maxHeight, height, orientation, fade, className, }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
-
-interface SearchInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
-    value?: string;
-    defaultValue?: string;
-    onValueChange?: (value: string) => void;
-    /** Appelé à la validation, et après le délai si `searchDelay` est posé. */
-    onSearch?: (value: string) => void;
-    /**
-     * Millisecondes d'inactivité avant de déclencher `onSearch`.
-     *
-     * `0` — le défaut — ne déclenche qu'à la validation. Au-delà, la recherche
-     * part quand la frappe s'arrête : c'est ce que chaque projet réécrivait
-     * autour de ce champ.
-     */
-    searchDelay?: number;
-    clearable?: boolean;
-    searchLabel?: string;
-    clearLabel?: string;
-}
-/**
- * Une recherche, avec son délai.
- *
- * `searchDelay` vaut zéro par défaut : la recherche ne part qu'à la
- * validation. C'est le réglage sûr — une requête à chaque frappe se paie en
- * appels serveur, et le défaut ne doit pas engager ce coût sans qu'on l'ait
- * demandé.
- */
-declare const SearchInput: react.ForwardRefExoticComponent<SearchInputProps & react.RefAttributes<HTMLInputElement>>;
-
 /** Une paire nom / valeur. La valeur n'est jamais relue du serveur. */
 interface SecretEntry {
     key: string;
@@ -3315,12 +4307,39 @@ interface SecretFieldsProps {
     templates?: string[];
     /** La forme d'un nom valide. Par défaut, aucune contrainte. */
     keyPattern?: RegExp;
+    /** Les libellés ci-dessous viennent par défaut du groupe `secretFields` de la locale. */
     keyPatternMessage?: string;
     keyLabel?: string;
     valueLabel?: string;
     addLabel?: ReactNode;
     disabled?: boolean;
     className?: string;
+    /**
+     * Le bouton d'ajout : variante, taille, icône, classe. Son libellé passe
+     * par `addLabel`.
+     */
+    addButtonProps?: Partial<Omit<ButtonProps, "onClick" | "children" | "disabled">>;
+    /**
+     * Le bouton qui retire une ligne : icône, variante, taille.
+     *
+     * Son nom reste calculé ligne par ligne — « Retirer API_KEY » — pour que
+     * chaque bouton dise lequel il retire.
+     */
+    removeButtonProps?: Partial<Omit<IconButtonProps, "onClick" | "label" | "disabled">>;
+    /**
+     * Le champ du nom : placeholder, taille, classe.
+     *
+     * La valeur, la saisie et l'état d'erreur, avec son `aria-describedby`,
+     * restent calculés par ligne.
+     */
+    keyInputProps?: Partial<Omit<InputProps, "value" | "defaultValue" | "onChange" | "disabled" | "invalid" | "aria-describedby">>;
+    /**
+     * Le champ de la valeur : placeholder, jauge, classe.
+     *
+     * Pas d'`autoComplete` : `new-password` est ce qui empêche le navigateur
+     * de proposer le mot de passe du compte à la place du secret.
+     */
+    valueInputProps?: Partial<Omit<PasswordInputProps, "value" | "defaultValue" | "onChange" | "disabled" | "autoComplete">>;
 }
 /** Les valeurs effacées, les noms gardés — ce qu'on affiche après l'envoi. */
 declare function clearSecretValues(entries: SecretEntry[]): SecretEntry[];
@@ -3335,7 +4354,7 @@ declare function clearSecretValues(entries: SecretEntry[]): SecretEntry[];
  * Après l'envoi, `clearSecretValues` vide les valeurs : un secret ne reste pas
  * affiché dans un formulaire ouvert.
  */
-declare function SecretFields({ value, defaultValue, onValueChange, storedKeys, templates, keyPattern, keyPatternMessage, keyLabel, valueLabel, addLabel, disabled, className, }: SecretFieldsProps): react_jsx_runtime.JSX.Element;
+declare function SecretFields({ value, defaultValue, onValueChange, storedKeys, templates, keyPattern, keyPatternMessage: keyPatternMessageProp, keyLabel: keyLabelProp, valueLabel: valueLabelProp, addLabel: addLabelProp, disabled, className, addButtonProps, removeButtonProps, keyInputProps, valueInputProps, }: SecretFieldsProps): react_jsx_runtime.JSX.Element;
 /** Ce qu'il faut envoyer au serveur après une saisie dans `SecretFields`. */
 interface SecretChanges {
     /** À créer ou à remplacer (rotation) : nom → nouvelle valeur. */
@@ -3365,25 +4384,11 @@ interface SecretChanges {
  */
 declare function secretChanges(entries: SecretEntry[], storedKeys?: string[]): SecretChanges;
 
-interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
-    width?: CSSProperties["width"];
-    height?: CSSProperties["height"];
-    radius?: CSSProperties["borderRadius"];
-    circle?: boolean;
-}
-/**
- * La forme de ce qui n'est pas encore là.
- *
- * Aux dimensions du contenu attendu, et non d'une taille générique : c'est
- * ce qui évite le sursaut de mise en page à l'arrivée des données, lequel
- * fait cliquer à côté.
- */
-declare function Skeleton({ className, width, height, radius, circle, style, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
-
 interface StatisticProps {
     value: number;
     label?: ReactNode;
     format?: "number" | "currency" | "percent";
+    /** La langue du format. Par défaut, celle de la locale SIA. */
     locale?: string;
     currency?: string;
     precision?: number;
@@ -3399,12 +4404,20 @@ interface StatisticProps {
  * décide du sens et de la couleur. Une flèche passée en prop finit par
  * pointer vers le haut sur une baisse.
  */
-declare function Statistic({ value, label, format, locale, currency, precision, prefix, suffix, trend, className }: StatisticProps): react_jsx_runtime.JSX.Element;
+declare function Statistic({ value, label, format, locale: localeProp, currency, precision, prefix, suffix, trend, className }: StatisticProps): react_jsx_runtime.JSX.Element;
 
 interface StatCardProps extends StatisticProps {
     icon?: ReactNode;
     description?: ReactNode;
     action?: ReactNode;
+    /**
+     * Les props de la `Card` qui entoure l'indicateur — un `id`, un
+     * `aria-label`, un gestionnaire de clic. Sans `children` : le contenu est
+     * celui de l'indicateur. `className` s'ajoute à celui de la carte.
+     */
+    cardProps?: Partial<Omit<CardProps, "children">>;
+    /** Les props du `CardBody`, sans `children`, rempli par l'indicateur. */
+    cardBodyProps?: Partial<Omit<CardBodyProps, "children">>;
 }
 /**
  * Un indicateur, dans une carte.
@@ -3413,35 +4426,7 @@ interface StatCardProps extends StatisticProps {
  * presque toujours ensemble, et qu'il serait fastidieux de recomposer à
  * chaque tableau de bord.
  */
-declare function StatCard({ icon, description, action, className, ...statisticProps }: StatCardProps): react_jsx_runtime.JSX.Element;
-
-type StepStatus = "done" | "current" | "upcoming" | "error";
-interface StepItem {
-    key: string;
-    title: ReactNode;
-    description?: ReactNode;
-    icon?: ReactNode;
-    /** Forcé au besoin; sinon déduit de `current`. */
-    status?: StepStatus;
-    disabled?: boolean;
-}
-interface StepsProps {
-    items: StepItem[];
-    /** Index de l'étape en cours. Ce qui précède est fait, ce qui suit à venir. */
-    current?: number;
-    orientation?: "horizontal" | "vertical";
-    size?: "sm" | "md";
-    /** Rend les étapes cliquables — pour revenir en arrière dans un tunnel. */
-    onStepClick?: (item: StepItem, index: number) => void;
-    className?: string;
-}
-/**
- * Une progression en étapes.
- *
- * Le trait entre deux étapes se remplit plutôt que de changer de couleur d'un
- * coup : c'est ce qui donne le sens de la marche, vers l'avant.
- */
-declare function Steps({ items, current, orientation, size, onStepClick, className, }: StepsProps): react_jsx_runtime.JSX.Element;
+declare function StatCard({ icon, description, action, className, cardProps, cardBodyProps, ...statisticProps }: StatCardProps): react_jsx_runtime.JSX.Element;
 
 interface TabsProps {
     value?: string;
@@ -3538,6 +4523,12 @@ interface ToasterProps {
      */
     container?: HTMLElement | null | undefined;
     className?: string;
+    /**
+     * Les props du `Spinner` des annonces en attente (`toast.loading`,
+     * `toast.promise`) — variante, taille. Sans effet sur une annonce qui
+     * fournit sa propre `icon`.
+     */
+    spinnerProps?: Partial<SpinnerProps>;
 }
 /**
  * La pile visible.
@@ -3547,7 +4538,7 @@ interface ToasterProps {
  * d'apparaître près du geste qui l'a déclenchée et à une panne générale de
  * s'imposer en haut de l'écran.
  */
-declare function Toaster({ placement, limit, duration, width, offset, container, className, }: ToasterProps): react.ReactPortal | null;
+declare function Toaster({ placement, limit, duration, width, offset, container, className, spinnerProps, }: ToasterProps): react.ReactPortal | null;
 interface ToastProviderProps extends PropsWithChildren, ToasterProps {
 }
 /**
@@ -3575,59 +4566,6 @@ declare function useToast(): ((input: _sia_ui_headless.ToastInput) => string) &
     custom: (options: ToastOptions) => string;
 };
 
-interface ToggleProps {
-    pressed?: boolean;
-    defaultPressed?: boolean;
-    onPressedChange?: (pressed: boolean) => void;
-    children?: ReactNode;
-    icon?: ReactNode;
-    /** Obligatoire quand le contenu se réduit à une icône. */
-    ariaLabel?: string;
-    size?: ComponentSize;
-    tone?: ComponentTone;
-    variant?: "solid" | "outline" | "ghost";
-    disabled?: boolean;
-    className?: string;
-}
-/**
- * Un bouton à deux états.
- *
- * Ce n'est pas un `Switch` : un interrupteur décrit un réglage qui persiste,
- * une bascule décrit un état de l'interface ici et maintenant — gras, filtre
- * actif, colonne affichée. `aria-pressed` porte cette différence.
- */
-declare function Toggle({ pressed: pressedProp, defaultPressed, onPressedChange, children, icon, ariaLabel, size, tone, variant, disabled, className, }: ToggleProps): react_jsx_runtime.JSX.Element;
-interface ToggleGroupOption {
-    value: string;
-    label?: ReactNode;
-    icon?: ReactNode;
-    ariaLabel?: string;
-    disabled?: boolean;
-}
-interface ToggleGroupProps {
-    options: ToggleGroupOption[];
-    /** `single` : une valeur ou aucune. `multiple` : un tableau. */
-    type?: "single" | "multiple";
-    value?: string | string[];
-    defaultValue?: string | string[];
-    /** Une chaîne en `single`, un tableau en `multiple` — comme `value`. */
-    onValueChange?: (value: string | string[]) => void;
-    size?: ComponentSize;
-    tone?: ComponentTone;
-    /** Autorise à tout désélectionner en `single`. */
-    deselectable?: boolean;
-    disabled?: boolean;
-    ariaLabel?: string;
-    className?: string;
-}
-/**
- * Plusieurs bascules qui partagent une valeur.
- *
- * Le repère glisse d'une option à l'autre au lieu de sauter : c'est la même
- * idée que les onglets, et c'est ce qui rend le changement lisible.
- */
-declare function ToggleGroup({ options, type, value: valueProp, defaultValue, onValueChange, size, tone, deselectable, disabled, ariaLabel, className, }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
-
 interface TourStep {
     target: string;
     title: ReactNode;
@@ -3670,7 +4608,7 @@ interface TransferProps {
  * cocher de deux cents lignes ne montre plus ce qui est retenu, alors que
  * la colonne de droite ne contient que cela.
  */
-declare function Transfer({ items, targetKeys, onChange, sourceTitle, targetTitle, className }: TransferProps): react_jsx_runtime.JSX.Element;
+declare function Transfer({ items, targetKeys, onChange, sourceTitle: sourceTitleProp, targetTitle: targetTitleProp, className }: TransferProps): react_jsx_runtime.JSX.Element;
 
 interface TreeNode {
     key: Key;
@@ -3700,6 +4638,13 @@ interface TreeSelectProps {
     onValueChange?: (value: Key, node: TreeNode) => void;
     placeholder?: string;
     className?: string;
+    /**
+     * L'arbre du panneau : nœuds dépliés à l'ouverture, classe.
+     *
+     * Les nœuds, la sélection et son rappel restent au sélecteur, qui se
+     * referme sur le choix.
+     */
+    treeProps?: Partial<Omit<TreeProps, "nodes" | "selectedKey" | "onSelect">>;
 }
 /**
  * Un choix dans une arborescence.
@@ -3708,7 +4653,7 @@ interface TreeSelectProps {
  * attente » ne se réduit pas à « En attente » sans devenir ambigu dès qu'un
  * autre nœud porte le même nom.
  */
-declare function TreeSelect({ nodes, value, onValueChange, placeholder: placeholderProp, className }: TreeSelectProps): react_jsx_runtime.JSX.Element;
+declare function TreeSelect({ nodes, value, onValueChange, placeholder: placeholderProp, className, treeProps }: TreeSelectProps): react_jsx_runtime.JSX.Element;
 
 interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
     level?: 1 | 2 | 3 | 4 | 5 | 6;
@@ -3732,6 +4677,7 @@ declare function InlineCode({ className, ...props }: HTMLAttributes<HTMLElement>
 
 interface UnsavedChangesGuardProps {
     when: boolean;
+    /** Le message de la confirmation. Par défaut, `unsavedChangesGuard.message` de la locale. */
     message?: string;
 }
 /**
@@ -3742,7 +4688,14 @@ interface UnsavedChangesGuardProps {
  * confirmation interne, que `confirmUnsavedNavigation` déclenche avant une
  * navigation du routeur.
  */
-declare function UnsavedChangesGuard({ when, message }: UnsavedChangesGuardProps): null;
+declare function UnsavedChangesGuard({ when, message: messageProp }: UnsavedChangesGuardProps): null;
+/**
+ * La confirmation avant une navigation du routeur.
+ *
+ * Hors d'un composant, la locale n'est pas lisible : passer
+ * `locale.unsavedChangesGuard.message` (lu avec `useSiaLocale()`) pour un
+ * message dans la langue de l'application. À défaut, le message français.
+ */
 declare function confirmUnsavedNavigation(when: boolean, message?: string): boolean;
 
 interface WeekPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
@@ -3775,4 +4728,4 @@ interface YearPickerProps {
  */
 declare function YearPicker({ value, defaultValue, min, max, onValueChange, className }: YearPickerProps): react_jsx_runtime.JSX.Element;
 
-export { Accordion, type AccordionItem, type AccordionProps, type ActivityEntry, ActivityIcon, ActivityLog, type ActivityLogFilter, type ActivityLogProps, Alert, AlertCircleIcon, type AlertProps, AmountDisplay, type AmountDisplayProps, AppShell, AppShellBrand, type AppShellBrandProps, type AppShellCollapsible, type AppShellContentWidth, type AppShellMobileNav, type AppShellProps, AppShellRailItem, type AppShellRailItemProps, ArrowRightIcon, AspectRatio, type AspectRatioProps, AsyncState, type AsyncStateProps, type AuditEvent, AuditMeta, type AuditMetaProps, AuthLayout, type AuthLayoutProps, Autocomplete, type AutocompleteProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarShape, type AvatarSize, type AvatarStatus, type AvatarTint, type AvatarVariant, Badge, type BadgeProps, BottomTabs, type BottomTabsProps, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, type ButtonProps, Calendar, type CalendarDay, type CalendarEvent, CalendarIcon, type CalendarMode, type CalendarProps, type CalendarRangeValue, Can, type CanProps, Card, CardBody, CardFooter, CardHeader, Chart, type ChartProps, type ChartSeries, CheckIcon, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ChevronUpIcon, ClockIcon, Collapse, type CollapseProps, ColorPicker, type ColorPickerProps, type ColumnCardRole, type CommandItem, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, Container, ContextMenu, type ContextMenuProps, Countdown, type CountdownProps, type CrudActionOptions, type CrudCreateOptions, type CrudDialogOptions, type CrudDialogState, CrudDialogs, CrudPage, type CrudPageProps, CurrencyInput, type CurrencyInputProps, DEFAULT_COUNTRIES, DEFAULT_PAGE_SIZE_OPTIONS, DataTable, type DataTableColumn, type DataTableProps, type DataTableView, DatePicker, type DatePickerProps, DateRangeFilter, type DateRangeFilterProps, DateRangePicker, type DateRangePickerProps, type DateRangePreset, type DateRangeValue, DateTimePicker, type DateTimePickerProps, type DateTimeValue, type DescriptionItem, Descriptions, type DescriptionsProps, Divider, type DividerProps, Drawer, DrawerBody, DrawerClose, type DrawerComponent, DrawerFooter, DrawerHeader, type DrawerPosition, type DrawerProps, type DrawerRef, type DrawerSize, DrawerTitle, DropdownMenu, type DropdownMenuProps, DurationDisplay, type DurationDisplayProps, EmptyState, type EmptyStateProps, EntityMeta, type EntityMetaProps, ErrorState, type ErrorStateProps, EventCalendar, type EventCalendarProps, EyeIcon, EyeOffIcon, Field, type FieldBindingLike, type FieldProps, type FieldStatus, type FieldType, type FieldValue, FileUpload, type FileUploadProps, FiltersBar, type FiltersBarProps, FolderIcon, Form, type FormEntry, Field as FormField, type FormFieldConfig, type FormFieldGroup, type FieldProps as FormFieldProps, type FormProps, type FormShape, Heading, type HeadingProps, HomeIcon, HoverCard, type HoverCardProps, type IDrawerProps, type ILabelProps, type ITooltipProps, type ITooltipVariant, IconButton, type IconButtonProps, ImageUpload, type ImageUploadProps, InfoIcon, InlineCode, Input, InputNumber, type InputNumberProps, type InputProps, JsonEditor, type JsonEditorProps, KeyIcon, KpiGrid, type KpiGridProps, Label, type LabelProps, LockIcon, LogOutIcon, MarkdownEditor, type MarkdownEditorProps, type MenuEntry, type MenuItem, type MenuLabel, MenuList, type MenuListProps, type MenuSeparator, MiniCalendar, MinusIcon, Modal, type ModalProps, MonthPicker, type MonthPickerProps, MoreHorizontalIcon, MultiSelect, type MultiSelectProps, OtpInput, type OtpInputProps, Overlay, type OverlayPlacement, type OverlayProps, PageHeader, type PageHeaderProps, type PageSizeContext, Pagination, type PaginationProps, PasswordInput, type PasswordInputProps, type PasswordStrength, PencilIcon, PermissionGate, type PermissionGateProps, type PhoneCountry, PhoneInput, type PhoneInputProps, PlusIcon, Popover, type PopoverProps, Progress, type ProgressProps, QRCode, type QRCodeProps, Radio, RadioButton, type RadioButtonProps, RadioGroup, type RadioGroupProps, type RadioProps, Rating, type RatingProps, type ReferenceOption, ReferenceSelect, type ReferenceSelectProps, RelativeTime, type RelativeTimeProps, RequireSession, type RequireSessionProps, ResizablePanel, type ResizablePanelProps, type ResourceDefinition, type ResourceField, type ResourceFormMode, RichTextEditor, type RichTextEditorProps, type RowAction, ScrollArea, type ScrollAreaProps, SearchIcon, SearchInput, type SearchInputProps, type SecretChanges, type SecretEntry, SecretFields, type SecretFieldsProps, Select, type SelectOption, type SelectProps, ServerIcon, SettingsIcon, Sidebar, type SidebarEntry, type SidebarItem, type SidebarProps, type SidebarRenderLink, type SidebarSection, type SidebarState, Skeleton, type SkeletonProps, Slider, type SliderProps, type SliderRangeValue, Sparkline, type SparklineProps, Spinner, type SpinnerProps, Stack, StarIcon, StatCard, type StatCardProps, Statistic, type StatisticProps, StatusBadge, type StatusBadgeProps, type StepItem, type StepStatus, Steps, type StepsProps, Switch, type SwitchProps, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, TagsInput, type TagsInputProps, type TanStackRouterLike, Text, type TextProps, Textarea, type TextareaProps, type TimeParts, TimePicker, type TimePickerProps, TimeRangePicker, type TimeRangePickerProps, type TimeRangeValue, Timeline, type TimelineItem, type TimelineProps, Timer, type TimerProps, ToastProvider, type ToastProviderProps, Toaster, type ToasterProps, Toggle, ToggleGroup, type ToggleGroupOption, type ToggleGroupProps, type ToggleProps, Tooltip, type TooltipProps, type TooltipVariant, Tour, type TourProps, type TourStep, Transfer, type TransferItem, type TransferProps, TrashIcon, Tree, type TreeNode, type TreeProps, TreeSelect, type TreeSelectProps, UnsavedChangesGuard, type UnsavedChangesGuardProps, UploadIcon, type UseDataTableQueryOptions, UserIcon, UsersIcon, WeekPicker, type WeekPickerProps, XIcon, YearPicker, type YearPickerProps, activityColumns, clearSecretValues, confirmUnsavedNavigation, createTanStackRouterStorage, createUrlTableStorage, defineResource, formFieldNames, formatDuration, formatTimeValue, initialsOf, parseTimeValue, resourceColumns, resourceDefaults, resourceDetailColumns, resourceFormFields, resourcePermissions, resourceRowKey, resourceSearchKeys, resourceValidator, secretChanges, tintForName, toneOf, useDataTableQuery, useToast };
+export { Accordion, type AccordionItem, type AccordionProps, AccountMenu, type AccountMenuProps, type ActivityEntry, ActivityIcon, ActivityLog, type ActivityLogFilter, type ActivityLogProps, Alert, AlertCircleIcon, type AlertProps, AmountDisplay, type AmountDisplayProps, AppShell, AppShellBrand, type AppShellBrandProps, type AppShellCollapsible, type AppShellContentWidth, type AppShellMobileNav, type AppShellProps, AppShellRailItem, type AppShellRailItemProps, ArrowRightIcon, AspectRatio, type AspectRatioProps, AsyncState, type AsyncStateProps, type AuditEvent, AuditMeta, type AuditMetaProps, AuthLayout, type AuthLayoutProps, Autocomplete, type AutocompleteProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarShape, type AvatarSize, type AvatarStatus, type AvatarTint, type AvatarVariant, Badge, type BadgeProps, BottomTabs, type BottomTabsProps, BrandIcon, type BrandIconData, type BrandIconProps, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, type ButtonProps, Calendar, type CalendarDay, type CalendarEvent, CalendarIcon, type CalendarMode, type CalendarProps, type CalendarRangeValue, Can, type CanProps, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, Chart, type ChartProps, type ChartSeries, CheckIcon, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, ChevronUpIcon, ClockIcon, Collapse, type CollapseProps, ColorModeToggle, type ColorModeToggleProps, ColorPicker, type ColorPickerProps, type ColumnCardRole, type CommandItem, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, Container, ContextMenu, type ContextMenuProps, Countdown, type CountdownProps, type CrudActionOptions, type CrudCreateOptions, type CrudDescriptionsProps, type CrudDialogOptions, type CrudDialogState, CrudDialogs, type CrudFormProps, type CrudModalProps, CrudPage, type CrudPageProps, CurrencyInput, type CurrencyInputProps, DEFAULT_COUNTRIES, DEFAULT_PAGE_SIZE_OPTIONS, DataTable, type DataTableColumn, type DataTableProps, type DataTableView, DatePicker, type DatePickerProps, DateRangeFilter, type DateRangeFilterProps, DateRangePicker, type DateRangePickerProps, type DateRangePreset, type DateRangeValue, DateTimePicker, type DateTimePickerProps, type DateTimeValue, type DescriptionItem, Descriptions, type DescriptionsProps, Divider, type DividerProps, Drawer, DrawerBody, DrawerClose, type DrawerComponent, DrawerFooter, DrawerHeader, type DrawerPosition, type DrawerProps, type DrawerRef, type DrawerSize, DrawerTitle, DropdownMenu, type DropdownMenuProps, DurationDisplay, type DurationDisplayProps, EmptyState, type EmptyStateProps, EntityMeta, type EntityMetaProps, ErrorState, type ErrorStateProps, EventCalendar, type EventCalendarLabels, type EventCalendarProps, type EventDraft, EventManager, type EventManagerLabels, type EventManagerProps, EyeIcon, EyeOffIcon, Field, type FieldBindingLike, type FieldControlOverrides, type FieldProps, type FieldStatus, type FieldType, type FieldValue, FileUpload, type FileUploadProps, FiltersBar, type FiltersBarProps, FolderIcon, Form, type FormEntry, Field as FormField, type FormFieldConfig, type FormFieldGroup, type FieldProps as FormFieldProps, type FormProps, type FormShape, Heading, type HeadingProps, HomeIcon, HoverCard, type HoverCardProps, type IDrawerProps, type ILabelProps, type ITooltipProps, type ITooltipVariant, IconButton, type IconButtonProps, ImageUpload, type ImageUploadProps, InfoIcon, InlineCode, Input, InputNumber, type InputNumberProps, type InputProps, type JobInstant, JobProgress, type JobProgressLabels, type JobProgressProps, type JobStatus, JsonEditor, type JsonEditorProps, JsonView, type JsonViewProps, KeyIcon, KpiGrid, type KpiGridProps, Label, type LabelProps, LiveIndicator, type LiveIndicatorProps, type LiveStatus, LockIcon, type LogLevel, type LogLine, LogOutIcon, LogStream, type LogStreamProps, MarkdownEditor, type MarkdownEditorProps, type MenuEntry, type MenuHeader, type MenuItem, type MenuLabel, MenuList, type MenuListProps, type MenuOverlayProps, type MenuSeparator, MiniCalendar, MinusIcon, Modal, type ModalProps, MonthPicker, type MonthPickerProps, MoonIcon, MoreHorizontalIcon, MultiSelect, type MultiSelectProps, OtpInput, type OtpInputProps, Overlay, type OverlayPlacement, type OverlayProps, PageHeader, type PageHeaderProps, type PageSizeContext, Pagination, type PaginationProps, PasswordInput, type PasswordInputProps, type PasswordStrength, PencilIcon, PermissionGate, type PermissionGateProps, type PhoneCountry, PhoneInput, type PhoneInputProps, PlusIcon, Popover, type PopoverProps, Progress, type ProgressProps, QRCode, type QRCodeProps, Radio, RadioButton, type RadioButtonProps, RadioGroup, type RadioGroupProps, type RadioProps, Rating, type RatingProps, type ReferenceOption, ReferenceSelect, type ReferenceSelectProps, RelativeTime, type RelativeTimeProps, RequireSession, type RequireSessionProps, ResizablePanel, type ResizablePanelProps, type ResourceDefinition, type ResourceField, type ResourceFormMode, RichTextEditor, type RichTextEditorProps, type RowAction, ScrollArea, type ScrollAreaProps, SearchIcon, SearchInput, type SearchInputProps, type SecretChanges, type SecretEntry, SecretFields, type SecretFieldsProps, Select, type SelectOption, type SelectProps, ServerIcon, SettingsIcon, Sidebar, type SidebarEntry, type SidebarItem, type SidebarProps, type SidebarRenderLink, type SidebarSection, type SidebarState, Skeleton, type SkeletonProps, Slider, type SliderProps, type SliderRangeValue, Sparkline, type SparklineProps, Spinner, type SpinnerProps, Stack, StarIcon, StatCard, type StatCardProps, Statistic, type StatisticProps, StatusBadge, type StatusBadgeProps, type StepItem, type StepStatus, Steps, type StepsProps, SunIcon, Switch, type SwitchProps, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, TagsInput, type TagsInputProps, type TanStackRouterLike, Text, type TextProps, Textarea, type TextareaProps, type TimeParts, TimePicker, type TimePickerProps, TimeRangePicker, type TimeRangePickerProps, type TimeRangeValue, Timeline, type TimelineItem, type TimelineProps, Timer, type TimerProps, ToastProvider, type ToastProviderProps, Toaster, type ToasterProps, Toggle, ToggleGroup, type ToggleGroupOption, type ToggleGroupProps, type ToggleProps, Tooltip, type TooltipProps, type TooltipVariant, Tour, type TourProps, type TourStep, Transfer, type TransferItem, type TransferProps, TrashIcon, Tree, type TreeNode, type TreeProps, TreeSelect, type TreeSelectProps, UnsavedChangesGuard, type UnsavedChangesGuardProps, UploadIcon, type UseDataTableQueryOptions, UserIcon, UsersIcon, WeekPicker, type WeekPickerProps, XIcon, YearPicker, type YearPickerProps, activityColumns, clearSecretValues, confirmUnsavedNavigation, createTanStackRouterStorage, createUrlTableStorage, defineResource, formFieldNames, formatDuration, formatTimeValue, initialsOf, parseTimeValue, resourceColumns, resourceDefaults, resourceDetailColumns, resourceFormFields, resourcePermissions, resourceRowKey, resourceSearchKeys, resourceValidator, secretChanges, tintForName, toneOf, useDataTableQuery, useToast };