@sia-ui/react-web 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode, RefObject, ImgHTMLAttributes, HTMLAttributes, ButtonHTMLAttributes, InputHTMLAttributes, Key, ForwardRefExoticComponent, RefAttributes, ReactElement, TextareaHTMLAttributes, SVGProps, CSSProperties, PropsWithChildren } from 'react';
+import { ReactNode, ReactElement, RefObject, ImgHTMLAttributes, HTMLAttributes, ButtonHTMLAttributes, InputHTMLAttributes, Key, TextareaHTMLAttributes, ForwardRefExoticComponent, RefAttributes, SVGProps, CSSProperties, PropsWithChildren } from 'react';
 import { ComponentTone, ComponentSize } from '@sia-ui/tokens';
 import * as _sia_ui_headless from '@sia-ui/headless';
-import { Placement, TableSort, TableQueryStorage, TableQueryState, TableQuery, SliderValue, FormAdapter, FormValidator, SessionStore, SessionState, PermissionRule, ToastPlacement, ToastId, ToastOptions } from '@sia-ui/headless';
+import { PermissionRule, Placement, SliderValue, FormAdapter, FormValidator, TableQueryStorage, TableQueryState, TableQuery, SessionStore, SessionState, ToastPlacement, ToastId, ToastOptions } from '@sia-ui/headless';
 export { SliderValue, ToastId, ToastOptions, ToastPlacement, ToastTone, toast, toastStore } from '@sia-ui/headless';
+import { Rule } from '@sia-ui/utils/validation';
 
 interface AccordionItem {
     key: string;
@@ -62,6 +63,13 @@ interface AlertProps {
     onDismiss?: () => void;
     className?: string;
 }
+/**
+ * Un message qui reste à l'écran.
+ *
+ * À la différence d'une annonce, il ne part pas tout seul : il décrit un
+ * état de la page — un solde insuffisant, une synchronisation en retard —
+ * et disparaît quand cet état change, pas au bout de cinq secondes.
+ */
 declare function Alert({ tone, title, children, action, dismissLabel: dismissLabelProp, onDismiss, className }: AlertProps): react_jsx_runtime.JSX.Element;
 
 interface AmountDisplayProps {
@@ -74,18 +82,276 @@ interface AmountDisplayProps {
     tone?: ComponentTone;
     className?: string;
 }
+/**
+ * Un montant, lisible d'un coup d'œil.
+ *
+ * Le signe est porté par la mise en forme et non par le nombre : un débit
+ * de 12 000 francs s'écrit « -12 000 F CFA », jamais « 12 000 F CFA » en
+ * 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;
 
-interface AppShellProps {
-    logo?: ReactNode;
-    navigation: ReactNode;
+interface SidebarItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Rend l'entrée comme un lien. Sans lui, c'est un bouton. */
+    href?: string;
+    /**
+     * Une pastille — un nombre de messages, d'alertes.
+     *
+     * Sur le rail réduit il ne reste pas la place de la lire : elle devient un
+     * point, et le compte exact revient dans le volet.
+     */
+    badge?: ReactNode;
+    disabled?: boolean;
+    /**
+     * La règle qui autorise l'entrée, évaluée par `can`.
+     *
+     * > Ceci masque une entrée de menu; ça ne protège pas la route.
+     */
+    permission?: PermissionRule;
+    /** Garde le parent même si toute sa descendance est filtrée. */
+    keepWhenEmpty?: boolean;
+    /** Sous-entrées, sans limite de profondeur. */
+    items?: SidebarItem[];
+    onClick?: () => void;
+}
+interface SidebarSection {
+    key: string;
+    /** Le titre du groupe. Réduit à un trait en mode rail. */
+    title: ReactNode;
+    permission?: PermissionRule;
+    items: SidebarItem[];
+}
+type SidebarEntry = SidebarItem | SidebarSection;
+/**
+ * Le point d'extension pour brancher un routeur.
+ *
+ * Sans lui, un `<a href>` est rendu — ce qui permet d'afficher la navigation
+ * hors de tout contexte de routage, en story comme en test. Avec lui, un
+ * `<Link>` de n'importe quelle bibliothèque, sans que le composant en dépende.
+ *
+ * À stabiliser avec `useCallback` : les nœuds sont mémoïsés, et une fonction
+ * recréée à chaque rendu annule cette mémoïsation.
+ */
+type SidebarRenderLink = (args: {
+    item: SidebarItem;
+    children: ReactNode;
+    /**
+     * À répandre tel quel sur le lien : `<Link {...props}>{children}</Link>`.
+     *
+     * Regroupés plutôt qu'éparpillés parce que `aria-current` en faisait
+     * partie : passé à côté, il se perdait sans bruit, et l'entrée courante
+     * n'était plus annoncée aux lecteurs d'écran.
+     */
+    props: {
+        className: string;
+        onClick: () => void;
+        "aria-current"?: "page";
+        title?: string;
+    };
+}) => ReactElement;
+interface SidebarProps {
+    items: SidebarEntry[];
+    /** La clé de l'entrée courante. Sa branche s'ouvre d'elle-même. */
+    activeKey?: string;
+    /**
+     * Le rail : les libellés disparaissent, les sous-menus passent en volet.
+     *
+     * Ils y restent atteignables — c'est tout l'objet du volet. Un menu réduit
+     * qui enferme ses enfants n'est pas réduit, il est cassé.
+     */
+    collapsed?: boolean;
+    /** De quel côté sortent les volets du rail. */
+    side?: "left" | "right";
+    variant?: "default" | "filled" | "floating";
+    size?: "sm" | "md" | "lg";
+    tone?: ComponentTone;
+    /**
+     * Évalue les règles de permission des entrées.
+     *
+     * Vient d'un `createAccessLayer` de `@sia-ui/headless`, ou de n'importe
+     * quelle fonction. Absent, aucune entrée n'est filtrée.
+     */
+    can?: (rule: PermissionRule) => boolean;
+    /** Les branches ouvertes. Non fourni, le composant les gère lui-même. */
+    openKeys?: string[];
+    defaultOpenKeys?: string[];
+    onOpenKeysChange?: (keys: string[]) => void;
+    /** Une seule branche ouverte par niveau. */
+    accordion?: boolean;
+    renderLink?: SidebarRenderLink;
     header?: ReactNode;
+    footer?: ReactNode;
+    onNavigate?: (item: SidebarItem) => void;
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * La navigation principale.
+ *
+ * Trois choses la distinguent d'une liste de liens : elle descend aussi
+ * 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;
+
+interface BottomTabsProps {
+    /** Attendu déjà filtré : la coquille a fait le tri une seule fois. */
+    items: SidebarItem[];
+    activeKey?: string;
+    /**
+     * Nombre d'onglets avant le bouton « Plus ».
+     *
+     * Quatre au maximum sur un téléphone : au-delà, les cibles tactiles
+     * descendent sous les quarante-quatre pixels recommandés, et on rate
+     * l'onglet voisin une fois sur trois.
+     */
+    max?: number;
+    renderLink?: SidebarRenderLink;
+    onNavigate?: (item: SidebarItem) => void;
+    /** Le bouton qui ouvre l'arborescence complète. */
+    more?: ReactNode;
+    onMore?: () => void;
+    moreLabel?: string;
+    className?: string;
+}
+/**
+ * La navigation d'un téléphone.
+ *
+ * Un rail d'icônes muettes n'est pas utilisable au comptoir : sur petit écran
+ * la navigation descend en bas, à portée du pouce, avec des libellés.
+ *
+ * Les onglets ne montrent que des **feuilles**. Un onglet qui ouvrirait un
+ * sous-menu depuis une barre basse serait un piège tactile — on vise une
+ * destination, on obtient un menu. Le reste de l'arborescence passe par
+ * « Plus ».
+ */
+declare const BottomTabs: react.NamedExoticComponent<BottomTabsProps>;
+
+/**
+ * L'état de la barre latérale sur grand écran.
+ *
+ * Trois valeurs et non un booléen : « réduite » et « masquée » sont deux
+ * intentions différentes, et une application qui veut l'une ne veut
+ * généralement pas l'autre. Sous le seuil mobile, l'état est ignoré — la
+ * barre cède la place à la navigation basse.
+ */
+type SidebarState = "expanded" | "collapsed" | "hidden";
+/**
+ * Ce que fait le bouton de bascule.
+ *
+ * `icon` alterne déployé et rail, `offcanvas` alterne déployé et masqué,
+ * `false` retire le bouton.
+ */
+type AppShellCollapsible = "icon" | "offcanvas" | false;
+/**
+ * La navigation sous le seuil mobile.
+ *
+ * `both` n'est pas un défaut par hasard : deux systèmes de navigation
+ * simultanés se disputent l'attention, et l'utilisateur ne sait plus lequel
+ * fait autorité.
+ */
+type AppShellMobileNav = "drawer" | "tabs" | "both";
+type AppShellContentWidth = "wide" | "narrow" | "full";
+interface AppShellProps {
+    nav: SidebarEntry[];
     children: ReactNode;
+    /**
+     * La clé de l'entrée courante.
+     *
+     * Laissée vide, elle est déduite de `currentPath`. La fournir explicitement
+     * ne sert que si les clés ne correspondent à aucune adresse.
+     */
+    activeKey?: string;
+    /**
+     * L'adresse courante — **le point d'accroche du routeur**.
+     *
+     * Une seule chaîne, que tous savent produire :
+     *
+     * ```tsx
+     * const { pathname } = useLocation();      // React Router
+     * const pathname = usePathname();          // Next.js
+     * const [pathname] = useLocation();        // wouter
+     * ```
+     *
+     * De là, la coquille déduit l'entrée active par le préfixe le plus long, et
+     * referme le tiroir mobile à chaque navigation — sans jamais importer de
+     * routeur.
+     */
+    currentPath?: string;
+    /** Branche les liens sur le routeur. À stabiliser avec `useCallback`. */
+    renderLink?: SidebarRenderLink;
+    onNavigate?: (item: SidebarItem) => void;
+    /**
+     * Évalue les règles de permission.
+     *
+     * Le filtrage est fait **une seule fois** ici : ni la barre latérale ni les
+     * onglets ne doivent avoir leur propre idée de ce qui est visible.
+     */
+    can?: (rule: PermissionRule) => boolean;
+    /**
+     * En tête de barre latérale : logo, nom du produit, sélecteur d'entité.
+     *
+     * Reçoit `data-collapsed` en mode rail, comme `sidebarFooter` : sans quoi
+     * un nom de produit écrit en toutes lettres déborde des quatre rem du rail.
+     */
+    brand?: ReactNode;
+    /**
+     * Bas de la barre latérale, sous la navigation.
+     *
+     * C'est la place de la déconnexion et des réglages du compte — ce qui sort
+     * de l'application, par opposition à l'en-tête, réservé à ce qui agit sur
+     * l'écran courant. Reçoit `data-collapsed` en mode rail, de quoi masquer un
+     * libellé sans changer de composant.
+     */
+    sidebarFooter?: ReactNode;
+    /** La barre du haut : recherche, notifications, avatar de compte. */
+    header?: ReactNode;
+    /**
+     * Au-dessus du contenu, pleine largeur de la zone.
+     *
+     * L'endroit d'un `PageHeader`. La coquille ne prend pas de `title` : un
+     * `<h1>` rendu par la coquille force chaque page à passer par ses props, et
+     * une page qui veut deux titres ou une mise en page à elle doit se battre.
+     */
+    page?: ReactNode;
     footer?: ReactNode;
-    defaultCollapsed?: boolean;
+    /**
+     * La largeur de la zone de contenu.
+     *
+     * Décidée ici plutôt qu'écran par écran : des largeurs posées page après
+     * page finissent par diverger, et personne ne sait laquelle fait foi.
+     */
+    contentWidth?: AppShellContentWidth;
+    side?: "left" | "right";
+    variant?: "default" | "filled" | "floating";
+    /** L'en-tête suit-il le défilement. */
+    stickyHeader?: boolean;
+    sidebarState?: SidebarState;
+    defaultSidebarState?: SidebarState;
+    onSidebarStateChange?: (state: SidebarState) => void;
+    collapsible?: AppShellCollapsible;
+    /** Toute valeur CSS : `16rem`, `280px`, `min(20vw, 320px)`. */
+    sidebarWidth?: string;
+    sidebarCollapsedWidth?: string;
+    mobileNav?: AppShellMobileNav;
+    /** Sous cette largeur, la barre latérale cède la place. */
+    mobileBreakpoint?: number;
+    ariaLabel?: string;
     className?: string;
 }
-declare function AppShell({ logo, navigation, header, children, footer, defaultCollapsed, className }: AppShellProps): react_jsx_runtime.JSX.Element;
+/**
+ * La coquille d'une application.
+ *
+ * Elle n'invente rien : la navigation est le `Sidebar`, le tiroir est le
+ * `Drawer`, les droits viennent de `@sia-ui/headless`. Ce qu'elle apporte est
+ * 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;
 
 interface AspectRatioProps {
     /** Le rapport largeur / hauteur. `16 / 9`, `1`, `4 / 3`. */
@@ -112,6 +378,13 @@ interface AsyncStateProps {
     onRetry?: () => void;
     children: ReactNode;
 }
+/**
+ * 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 {
@@ -127,6 +400,14 @@ interface AuditMetaProps {
     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 {
@@ -138,9 +419,24 @@ interface AuthLayoutProps {
     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;
 
-type OverlayPlacement = "bottom-start" | "bottom-end" | "top-start" | "top-end";
+/**
+ * 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>;
@@ -154,6 +450,16 @@ interface OverlayProps {
     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 SelectOption {
@@ -192,6 +498,17 @@ interface SelectProps {
     "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 AutocompleteProps {
@@ -209,14 +526,94 @@ interface AutocompleteProps {
     "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;
 
-interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "children"> {
+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?: "sm" | "md" | "lg";
-    fallback?: 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;
 }
-declare function Avatar({ name, size, fallback, className, src, alt, onError, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+/**
+ * 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;
@@ -224,6 +621,13 @@ interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
     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> {
@@ -235,6 +639,13 @@ interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
     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;
 
 interface BreadcrumbItem {
@@ -308,6 +719,13 @@ interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     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 CalendarDay {
@@ -358,8 +776,27 @@ interface CalendarProps {
     tone?: ComponentTone;
     className?: string;
 }
+/**
+ * Un mois de dates, sélectionnables une à une ou par plage.
+ *
+ * Trois panneaux — jours, mois, années — plutôt qu'un défilement infini :
+ * choisir une date de naissance demande de remonter trente ans, et trente
+ * ans de défilement ne sont pas une navigation.
+ *
+ * Les dates circulent en chaînes `AAAA-MM-JJ`, jamais en objets `Date` : un
+ * `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;
 
+/**
+ * Une surface qui regroupe ce qui va ensemble.
+ *
+ * Quatre parties séparées — `Card`, `CardHeader`, `CardBody`, `CardFooter` —
+ * plutôt que des props `title` et `footer` : dès qu'un en-tête doit porter
+ * 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;
@@ -432,6 +869,14 @@ interface CheckboxGroupProps {
     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;
@@ -449,6 +894,13 @@ interface ColorPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "
     onValueChange?: (value: string) => void;
     showValue?: boolean;
 }
+/**
+ * Le choix d'une couleur.
+ *
+ * La valeur hexadécimale est affichée à côté du nuancier : deux bleus
+ * voisins ne se distinguent pas à l'œil sur un écran mal calibré, alors que
+ * leurs codes, si.
+ */
 declare const ColorPicker: react.ForwardRefExoticComponent<ColorPickerProps & react.RefAttributes<HTMLInputElement>>;
 
 interface CommandItem {
@@ -468,6 +920,13 @@ interface CommandPaletteProps {
     emptyLabel?: string;
     className?: string;
 }
+/**
+ * Tout ce que l'application sait faire, au clavier.
+ *
+ * La recherche porte aussi sur des mots-clés invisibles : quelqu'un qui tape
+ * « 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;
 
 interface ConfirmDialogProps {
@@ -481,8 +940,22 @@ interface ConfirmDialogProps {
     loading?: boolean;
     onConfirm: () => void | Promise<void>;
 }
+/**
+ * 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 }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * La largeur de lecture, et l'espacement vertical.
+ *
+ * Deux réglages posés une fois pour toutes plutôt qu'une marge inventée
+ * écran par écran : des largeurs décidées page après page finissent par
+ * diverger, et personne ne sait plus laquelle fait foi.
+ */
 declare function Container({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
 declare function Stack({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
 
@@ -505,98 +978,225 @@ interface TimeParts {
 declare function parseTimeValue(value?: string): TimeParts;
 declare function formatTimeValue(parts: TimeParts, showSeconds?: boolean): string;
 declare function formatDuration(milliseconds: number, showMilliseconds?: boolean): string;
+/**
+ * Un temps qui s'écoule, dans un sens ou dans l'autre.
+ *
+ * L'intervalle est réglable et vaut 250 ms par défaut : une pendule au
+ * dixième de seconde redessine quarante fois par seconde pour un chiffre
+ * que personne ne lit.
+ */
 declare function Timer({ duration, initialValue, direction, running, interval, onChange, onFinish, format, className }: TimerProps): react_jsx_runtime.JSX.Element;
 
 type CountdownProps = Omit<TimerProps, "direction">;
+/**
+ * Un `Timer` qui descend.
+ *
+ * Le compte à rebours est assez fréquent — une session qui expire, un code
+ * à usage unique — pour mériter son nom plutôt qu'une prop à ne pas
+ * oublier.
+ */
 declare function Countdown(props: CountdownProps): react_jsx_runtime.JSX.Element;
 
-interface CrudPageProps {
-    title: ReactNode;
-    description?: ReactNode;
-    actions?: ReactNode;
-    toolbar?: ReactNode;
-    children: ReactNode;
-    loading?: boolean;
-    error?: ReactNode;
-    empty?: boolean;
-    emptyTitle?: ReactNode;
-    page?: number;
-    totalPages?: number;
-    onPageChange?: (page: number) => void;
-    className?: string;
-}
-declare function CrudPage({ title, description, actions, toolbar, children, loading, error, empty, emptyTitle, page, totalPages, onPageChange, className }: CrudPageProps): react_jsx_runtime.JSX.Element;
-
-interface CurrencyInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "inputMode"> {
-    value?: number | null;
-    defaultValue?: number | null;
-    currency?: string;
-    locale?: string;
-    onValueChange?: (value: number | null) => void;
-    invalid?: boolean;
-}
-declare const CurrencyInput: react.ForwardRefExoticComponent<CurrencyInputProps & react.RefAttributes<HTMLInputElement>>;
-
+/** Liste dense, ou grille de cartes. */
+type DataTableView = "table" | "cards";
+/**
+ * Le rôle d'une colonne dans la carte.
+ *
+ * `title` sert d'en-tête — la première colonne le prend si rien n'est
+ * déclaré. `meta` s'affiche en paire libellé / valeur. `hidden` reste au
+ * tableau seul : une carte qui recopie douze colonnes n'est plus une carte.
+ */
+type ColumnCardRole = "title" | "meta" | "hidden";
 interface DataTableColumn<T> {
     key: string;
     header: ReactNode;
-    cell: (row: T) => ReactNode;
-    align?: "left" | "center" | "right";
+    /**
+     * Où lire la valeur : une clé de l'objet, ou une fonction pour les valeurs
+     * calculées. Sert au rendu par défaut, à la carte et à la recherche locale.
+     */
+    accessor?: keyof T | ((row: T) => unknown);
+    /** Rendu personnalisé. Prioritaire sur `accessor`. */
+    cell?: (row: T, index: number) => ReactNode;
+    align?: "start" | "center" | "end";
+    /**
+     * Largeur suggérée — `120px`, `20%`.
+     *
+     * En `layout="auto"` (défaut) le navigateur n'y voit qu'une indication.
+     * Pour qu'elle soit tenue, passer en `layout="fixed"`.
+     */
     width?: string;
-    /** Rend l'entête cliquable. Le tri lui-même appartient au serveur. */
+    minWidth?: string;
+    /** Coupe au lieu d'élargir. Indispensable en `layout="fixed"`. */
+    truncate?: boolean;
+    /** Retire la colonne du tableau sans toucher à la carte. */
+    hidden?: boolean;
+    /** Rend l'en-tête cliquable. Le tri lui-même reste au serveur. */
     sortable?: boolean;
     /** Le champ envoyé au serveur, si différent de `key`. */
     sortKey?: string;
+    /** Place de la colonne dans la carte. */
+    card?: ColumnCardRole;
+    headerClassName?: string;
+    cellClassName?: string;
+}
+interface RowAction<T> {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    tone?: ComponentTone;
+    /** Masque l'action pour cette ligne — un solde nul, un envoi déjà annulé. */
+    hidden?: (row: T, index: number) => boolean;
+    disabled?: (row: T, index: number) => boolean;
+    /** Même grammaire de droits que la navigation. */
+    permission?: PermissionRule;
+    /** Demande confirmation. Obligatoire pour tout ce qui détruit. */
+    confirm?: {
+        title: ReactNode;
+        description?: ReactNode;
+        confirmLabel?: string;
+        cancelLabel?: string;
+        destructive?: boolean;
+    };
+    onSelect: (row: T, index: number) => void | Promise<void>;
 }
 interface DataTableProps<T> {
     columns: Array<DataTableColumn<T>>;
     data: T[];
-    getRowKey: (row: T) => Key;
-    caption?: string;
-    empty?: ReactNode;
+    /** La clé d'une ligne. Sans elle, l'index — à éviter si les lignes bougent. */
+    getRowKey?: (row: T, index: number) => Key;
+    title?: ReactNode;
+    description?: ReactNode;
+    /** Zone libre : filtres, sélecteur de période. */
+    toolbar?: ReactNode;
+    /** Actions globales, à droite. */
+    actions?: ReactNode;
+    /**
+     * Les clés sur lesquelles porte la recherche.
+     *
+     * Absente, aucun champ n'est affiché : un tableau sans champ déclaré n'a
+     * rien à chercher. Le filtrage est local, sur les lignes déjà chargées.
+     */
+    searchKeys?: string[];
+    searchPlaceholder?: string;
+    /** Recherche déléguée. Fournie, le tableau cesse de filtrer lui-même. */
+    onSearch?: (query: string) => void;
+    layout?: "auto" | "fixed";
+    /** Hauteur du corps. Sans elle, `stickyHeader` n'a rien où se coller. */
+    maxHeight?: string;
+    stickyHeader?: boolean;
+    density?: "compact" | "default" | "comfortable";
+    /** Un fond alterné, une ligne sur deux. */
+    striped?: boolean;
+    bordered?: boolean;
+    rowActions?: Array<RowAction<T>> | ((row: T, index: number) => Array<RowAction<T>>);
+    /** Au-delà, les actions passent dans un menu. */
+    inlineActionsLimit?: number;
+    actionsHeader?: ReactNode;
+    /** `icon` garde la colonne étroite sur un tableau déjà large. */
+    actionsDisplay?: "icon" | "label";
+    /** Évalue les règles de permission des actions. */
+    can?: (rule: PermissionRule) => boolean;
+    view?: DataTableView;
+    defaultView?: DataTableView;
+    onViewChange?: (view: DataTableView) => void;
+    showViewToggle?: boolean;
+    /**
+     * Bascule en cartes sous le point de rupture. Actif par défaut : un
+     * tableau à sept colonnes est illisible sur un téléphone.
+     */
+    responsive?: boolean;
+    cardsBreakpoint?: number;
+    /** Rendu complet d'une carte. Sans lui, elle est déduite des colonnes. */
+    renderCard?: (row: T, index: number) => ReactNode;
     loading?: boolean;
-    /** Le tri en vigueur — celui de `useTableQuery`, ou le vôtre. */
-    sort?: TableSort | null;
+    /** Lignes fantômes pendant le premier chargement. */
+    skeletonRows?: number;
+    error?: ReactNode;
+    onRetry?: () => void;
+    empty?: {
+        title?: ReactNode;
+        description?: ReactNode;
+        action?: ReactNode;
+    };
+    /**
+     * Ajoute une colonne de cases à cocher.
+     *
+     * Sur une liste paginée côté serveur, la case d'en-tête ne porte que sur la
+     * page affichée : le composant ne connaît pas les lignes qu'il n'a pas
+     * reçues, et prétendre « tout sélectionner » serait un mensonge.
+     */
+    selectable?: boolean;
+    selectedKeys?: Key[];
+    defaultSelectedKeys?: Key[];
+    onSelectionChange?: (keys: Key[], rows: T[]) => void;
+    isRowSelectable?: (row: T, index: number) => boolean;
+    /** Barre affichée dès qu'une ligne est cochée. */
+    selectionActions?: (context: {
+        keys: Key[];
+        rows: T[];
+        clear: () => void;
+    }) => ReactNode;
+    sort?: {
+        field: string;
+        direction: "asc" | "desc";
+    } | null;
     onSortChange?: (field: string) => void;
-    /** L'entête reste visible quand le tableau défile. */
-    stickyHeader?: boolean;
-    onRowClick?: (row: T) => void;
-    rowClassName?: (row: T) => string | undefined;
+    onRowClick?: (row: T, index: number) => void;
+    rowClassName?: (row: T, index: number) => string | undefined;
+    caption?: string;
     className?: string;
 }
-/**
- * Un tableau de données.
+
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    invalid?: boolean;
+    left?: ReactNode;
+    right?: ReactNode;
+    loading?: boolean;
+    loadingLabel?: string;
+    spinnerProps?: Omit<SpinnerProps, "label">;
+    variant?: "solid" | "outline" | "ghost" | "underline";
+    tone?: ComponentTone;
+    inputSize?: "sm" | "md" | "lg";
+    radius?: "default" | "none" | "sm" | "lg" | "full";
+}
+/**
+ * La saisie d'une ligne de texte.
  *
- * Il n'ordonne ni ne filtre rien lui-même : à partir de quelques centaines de
- * lignes, trier côté client veut dire les avoir toutes téléchargées. Le tri
- * est donc une intention envoyée au serveur — `onSortChange` — et le tableau
- * ne fait qu'afficher ce qu'on lui rend.
+ * `left` et `right` accueillent ce qui accompagne la valeur — une unité,
+ * une icône de recherche, un bouton de réinitialisation — à l'intérieur du
+ * cadre. Posés à côté, ils s'en désalignent dès que la taille change.
  */
-declare function DataTable<T>({ columns, data, getRowKey, caption, empty: emptyProp, loading, sort, onSortChange, stickyHeader, onRowClick, rowClassName, className, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    invalid?: boolean;
+    resize?: "none" | "vertical" | "horizontal" | "both";
+}
 /**
- * L'état du tableau dans la barre d'adresse.
+ * La saisie de plusieurs lignes.
  *
- * `history.replaceState` plutôt que `pushState` : trier une colonne trois
- * fois de suite ne doit pas demander trois retours en arrière pour revenir
- * d'où l'on vient.
+ * Elle garde la hauteur qu'on lui donne : un redimensionnement automatique
+ * fait sauter la page à chaque retour à la ligne, et déplace ce qu'on
+ * s'apprêtait à cliquer.
  */
-declare function createUrlTableStorage(mode?: "replace" | "push"): TableQueryStorage;
-interface UseDataTableQueryOptions {
-    defaultState?: Partial<TableQueryState>;
-    /** `false` garde l'état en mémoire — utile dans une modale. */
-    syncUrl?: boolean;
-    /** Empile une entrée d'historique à chaque changement. */
-    history?: "replace" | "push";
-    /** Préfixe des clés, pour deux tableaux sur la même page. */
-    prefix?: string;
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface CurrencyInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "inputMode"> {
+    value?: number | null;
+    defaultValue?: number | null;
+    currency?: string;
+    locale?: string;
+    onValueChange?: (value: number | null) => void;
+    invalid?: boolean;
 }
 /**
- * Tri, filtres et pagination d'un tableau, synchronisés avec l'URL.
+ * La saisie d'un montant.
  *
- * Le calcul vit dans `@sia-ui/headless`; il n'y a ici que le branchement sur
- * la barre d'adresse, qui est la seule partie propre au navigateur.
+ * La valeur rendue est un nombre, jamais la chaîne affichée : les espaces
+ * de milliers et le symbole appartiennent à l'affichage, et un serveur qui
+ * reçoit « 1 250 000 F CFA » ne peut rien en faire.
  */
-declare function useDataTableQuery(options?: UseDataTableQueryOptions): TableQuery;
+declare const CurrencyInput: react.ForwardRefExoticComponent<CurrencyInputProps & react.RefAttributes<HTMLInputElement>>;
 
 interface DatePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek" | "disabledDate" | "cellRender" | "showWeek"> {
     id?: string;
@@ -625,39 +1225,15 @@ interface DatePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek
     "aria-invalid"?: boolean;
     "aria-required"?: boolean;
 }
+/**
+ * Une date, choisie au calendrier ou saisie au clavier.
+ *
+ * La valeur est une chaîne `AAAA-MM-JJ` : un objet `Date` porte une heure
+ * et un fuseau dont une date d'échéance n'a que faire, et qui la décalent
+ * d'un jour selon l'endroit d'où on la lit.
+ */
 declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLButtonElement>>;
 
-type DateRangeValue = CalendarRangeValue;
-interface DateRangePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek" | "disabledDate" | "cellRender" | "showWeek"> {
-    value?: DateRangeValue;
-    defaultValue?: DateRangeValue;
-    onValueChange?: (value: DateRangeValue) => void;
-    min?: string;
-    max?: string;
-    startLabel?: string;
-    endLabel?: string;
-    allowClear?: boolean;
-    placement?: OverlayPlacement;
-    tone?: ComponentTone;
-    invalid?: boolean;
-    disabled?: boolean;
-    className?: string;
-}
-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;
-
-interface DateRangePreset {
-    label: ReactNode;
-    value: DateRangeValue;
-}
-interface DateRangeFilterProps {
-    value: DateRangeValue;
-    onValueChange: (value: DateRangeValue) => void;
-    presets?: DateRangePreset[];
-    onClear?: () => void;
-    className?: string;
-}
-declare function DateRangeFilter({ value, onValueChange, presets, onClear, className }: DateRangeFilterProps): react_jsx_runtime.JSX.Element;
-
 interface TimePickerProps {
     id?: string;
     name?: string;
@@ -689,6 +1265,13 @@ interface TimePickerProps {
     "aria-invalid"?: boolean;
     "aria-required"?: boolean;
 }
+/**
+ * Une heure, au pas voulu.
+ *
+ * `minuteStep` évite de faire défiler soixante minutes pour un rendez-vous
+ * qui tombe au quart d'heure. Les secondes ne s'affichent que si on les
+ * demande — la plupart des heures métier n'en ont pas.
+ */
 declare const TimePicker: react.ForwardRefExoticComponent<TimePickerProps & react.RefAttributes<HTMLButtonElement>>;
 
 interface DateTimeValue {
@@ -713,287 +1296,107 @@ interface DateTimePickerProps {
     timeProps?: Omit<TimePickerProps, "value" | "defaultValue" | "onValueChange" | "tone" | "invalid" | "disabled">;
     className?: string;
 }
+/**
+ * Une date et une heure, dans un seul champ.
+ *
+ * `needConfirm` existe parce que l'heure se choisit après la date : sans
+ * validation explicite, le panneau se referme sur la date et l'heure reste
+ * celle de la veille.
+ */
 declare function DateTimePicker({ value, defaultValue, onValueChange, minuteStep, secondStep, showSeconds, hourFormat, needConfirm, minDate, maxDate, tone, invalid, disabled, dateProps, timeProps, className }: DateTimePickerProps): 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;
+interface MultiSelectProps {
+    id?: string;
+    options: SelectOption[];
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    placeholder?: string;
+    searchable?: boolean;
+    disabled?: boolean;
     className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
 }
-declare function Descriptions({ items, title, columns, bordered, className }: DescriptionsProps): react_jsx_runtime.JSX.Element;
+/**
+ * Plusieurs choix dans une liste.
+ *
+ * Les valeurs retenues s'affichent dans le champ, retirables une à une :
+ * 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;
 
-interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+type RadioValue = string | number;
+interface RadioGroupProps {
+    id?: string;
+    name?: string;
+    label?: ReactNode;
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    onValueChange?: (value: RadioValue) => void;
     orientation?: "horizontal" | "vertical";
-    decorative?: boolean;
-}
-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;
-};
-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;
+    size?: "sm" | "md" | "lg";
+    tone?: ComponentTone;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+    children: ReactNode;
 }
-interface MenuSeparator {
-    key: string;
-    type: "separator";
+/**
+ * Un choix parmi plusieurs, tous visibles.
+ *
+ * Au-delà de cinq ou six options, une liste déroulante lit mieux : des
+ * boutons radio en montrent la totalité, ce qui est leur intérêt tant qu'on
+ * peut encore les embrasser du regard.
+ */
+declare function RadioGroup({ id, name, label, value, defaultValue, onValueChange, orientation, disabled, size, tone, className, children, ...ariaProps }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "name" | "value" | "size"> {
+    value: RadioValue;
+    label?: ReactNode;
+    children?: ReactNode;
 }
-interface MenuLabel {
-    key: string;
-    type: "label";
-    label: ReactNode;
+declare function Radio({ value, label, children, className, disabled, onChange, ...props }: RadioProps): react_jsx_runtime.JSX.Element;
+interface RadioButtonProps {
+    value: RadioValue;
+    disabled?: boolean;
+    children: ReactNode;
+    className?: string;
 }
-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;
+declare function RadioButton({ value, disabled, children, className }: RadioButtonProps): react_jsx_runtime.JSX.Element;
+
+interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    label?: ReactNode;
+    onCheckedChange?: (checked: boolean) => void;
 }
 /**
- * Le panneau seul, sans déclencheur.
+ * Une bascule à effet immédiat.
  *
- * Extrait parce que `DropdownMenu` et `ContextMenu` n'ont en commun que lui :
- * tout le reste — l'ancrage, le geste d'ouverture — diffère.
+ * À la différence d'une case à cocher, elle n'attend pas de validation :
+ * ce qu'on bascule s'applique tout de suite. Une case dans un formulaire,
+ * une bascule dans des réglages.
  */
-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;
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface FileUploadProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    label?: string;
+    description?: string;
+    onFilesChange?: (files: File[]) => void;
 }
 /**
- * Un menu accroché à un bouton.
+ * Un dépôt de fichiers, par clic ou par glisser.
  *
- * 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.
+ * Le glisser-déposer seul exclut le clavier et le tactile; le bouton seul
+ * ignore le geste que tout le monde essaie d'abord. Les deux mènent au même
+ * champ natif.
  */
-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;
-    locale?: string;
-    style?: "short" | "long" | "clock";
-    className?: string;
-}
-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;
-}
-declare function EmptyState({ icon, title, description, action, compact, className }: EmptyStateProps): react_jsx_runtime.JSX.Element;
-
-interface EntityMetaProps {
-    createdAt?: Date | string | number;
-    updatedAt?: Date | string | number;
-    createdBy?: ReactNode;
-    updatedBy?: ReactNode;
-    identifier?: string;
-    status?: ReactNode;
-    locale?: string;
-    className?: string;
-}
-declare function EntityMeta({ createdAt, updatedAt, createdBy, updatedBy, identifier, status, locale, className }: EntityMetaProps): react_jsx_runtime.JSX.Element;
-
-interface ErrorStateProps {
-    title?: ReactNode;
-    description?: ReactNode;
-    error?: unknown;
-    action?: ReactNode;
-    onRetry?: () => void;
-    retryLabel?: string;
-    compact?: boolean;
-    className?: string;
-}
-declare function ErrorState({ title: titleProp, description, error, action, onRetry, retryLabel: retryLabelProp, compact, className }: ErrorStateProps): react_jsx_runtime.JSX.Element;
-
-interface CalendarEvent {
-    id: string;
-    date: string;
-    title: string;
-    tone?: ComponentTone;
-}
-interface EventCalendarProps extends Omit<CalendarProps, "renderDay"> {
-    events: CalendarEvent[];
-    maxEventsPerDay?: number;
-    onEventClick?: (event: CalendarEvent) => void;
-}
-declare function EventCalendar({ events, maxEventsPerDay, onEventClick, ...props }: EventCalendarProps): react_jsx_runtime.JSX.Element;
-
-interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
-    invalid?: boolean;
-    left?: ReactNode;
-    right?: ReactNode;
-    loading?: boolean;
-    loadingLabel?: string;
-    spinnerProps?: Omit<SpinnerProps, "label">;
-    variant?: "solid" | "outline" | "ghost" | "underline";
-    tone?: ComponentTone;
-    inputSize?: "sm" | "md" | "lg";
-    radius?: "default" | "none" | "sm" | "lg" | "full";
-}
-declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
-
-interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
-    invalid?: boolean;
-    resize?: "none" | "vertical" | "horizontal" | "both";
-}
-declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
-
-interface MultiSelectProps {
-    id?: string;
-    options: SelectOption[];
-    value?: string[];
-    defaultValue?: string[];
-    onValueChange?: (value: string[]) => void;
-    placeholder?: string;
-    searchable?: boolean;
-    disabled?: boolean;
-    className?: string;
-    "aria-describedby"?: string;
-    "aria-labelledby"?: string;
-    "aria-invalid"?: boolean;
-    "aria-required"?: boolean;
-}
-declare function MultiSelect({ id, options, value, defaultValue, onValueChange, placeholder, searchable, disabled, className, ...ariaProps }: MultiSelectProps): react_jsx_runtime.JSX.Element;
-
-type RadioValue = string | number;
-interface RadioGroupProps {
-    id?: string;
-    name?: string;
-    label?: ReactNode;
-    value?: RadioValue;
-    defaultValue?: RadioValue;
-    onValueChange?: (value: RadioValue) => void;
-    orientation?: "horizontal" | "vertical";
-    disabled?: boolean;
-    size?: "sm" | "md" | "lg";
-    tone?: ComponentTone;
-    className?: string;
-    "aria-describedby"?: string;
-    "aria-labelledby"?: string;
-    "aria-invalid"?: boolean;
-    "aria-required"?: boolean;
-    children: ReactNode;
-}
-declare function RadioGroup({ id, name, label, value, defaultValue, onValueChange, orientation, disabled, size, tone, className, children, ...ariaProps }: RadioGroupProps): react_jsx_runtime.JSX.Element;
-interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "name" | "value" | "size"> {
-    value: RadioValue;
-    label?: ReactNode;
-    children?: ReactNode;
-}
-declare function Radio({ value, label, children, className, disabled, onChange, ...props }: RadioProps): react_jsx_runtime.JSX.Element;
-interface RadioButtonProps {
-    value: RadioValue;
-    disabled?: boolean;
-    children: ReactNode;
-    className?: string;
-}
-declare function RadioButton({ value, disabled, children, className }: RadioButtonProps): react_jsx_runtime.JSX.Element;
-
-interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
-    checked?: boolean;
-    defaultChecked?: boolean;
-    label?: ReactNode;
-    onCheckedChange?: (checked: boolean) => void;
-}
-declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
-
-interface FileUploadProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
-    label?: string;
-    description?: string;
-    onFilesChange?: (files: File[]) => void;
-}
 declare function FileUpload({ label, description, onFilesChange, className, multiple, accept, disabled, ...props }: FileUploadProps): react_jsx_runtime.JSX.Element;
 
 interface ImageUploadProps extends Omit<FileUploadProps, "accept" | "onFilesChange"> {
@@ -1002,6 +1405,13 @@ interface ImageUploadProps extends Omit<FileUploadProps, "accept" | "onFilesChan
     onValueChange?: (file: File | null, previewUrl?: string) => void;
     previewAlt?: string;
 }
+/**
+ * Un dépôt de fichier qui montre ce qu'on vient de choisir.
+ *
+ * L'aperçu est local, construit avant tout envoi : attendre le retour du
+ * 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;
 
 type SliderRangeValue = [number, number];
@@ -1062,6 +1472,12 @@ interface RatingProps {
     "aria-invalid"?: boolean;
     "aria-required"?: boolean;
 }
+/**
+ * Une note, en étoiles.
+ *
+ * `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;
 
 interface RichTextEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
@@ -1071,6 +1487,13 @@ interface RichTextEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onCh
     placeholder?: string;
     disabled?: boolean;
 }
+/**
+ * Une saisie de texte mis en forme.
+ *
+ * Elle rend du HTML, pas une structure à elle : ce qui sort se stocke, se
+ * 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;
 
 interface MarkdownEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange"> {
@@ -1079,6 +1502,13 @@ interface MarkdownEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaEl
     onValueChange?: (value: string) => void;
     preview?: (value: string) => ReactNode;
 }
+/**
+ * Une saisie Markdown, avec son aperçu.
+ *
+ * Le rendu n'est pas fourni : `preview` reçoit le texte et rend ce qu'il
+ * 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;
 
 interface JsonEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange"> {
@@ -1087,6 +1517,13 @@ interface JsonEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElemen
     onValueChange?: (value: string, parsed: unknown | undefined) => void;
     formatOnBlur?: boolean;
 }
+/**
+ * Une zone de saisie qui connaît la forme de ce qu'on y écrit.
+ *
+ * Elle signale une syntaxe invalide pendant la frappe et rend l'objet
+ * 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;
 
 interface OtpInputProps {
@@ -1104,6 +1541,13 @@ interface OtpInputProps {
     "aria-invalid"?: boolean;
     "aria-required"?: boolean;
 }
+/**
+ * Un code à usage unique, chiffre par chiffre.
+ *
+ * Le collage d'un code entier remplit toutes les cases d'un coup : c'est
+ * ainsi qu'on le récupère d'un SMS, et le forcer à être retapé serait une
+ * punition pour rien.
+ */
 declare function OtpInput({ id, value, defaultValue, onValueChange, length, inputMode, mask, disabled, className, ...ariaProps }: OtpInputProps): react_jsx_runtime.JSX.Element;
 
 interface TagsInputProps {
@@ -1121,6 +1565,13 @@ interface TagsInputProps {
     "aria-invalid"?: boolean;
     "aria-required"?: boolean;
 }
+/**
+ * Une liste de mots, saisis à la volée.
+ *
+ * Les séparateurs sont déclarés : la virgule et l'entrée par défaut, parce
+ * 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;
 
 interface ReferenceOption extends SelectOption {
@@ -1129,6 +1580,13 @@ interface ReferenceOption extends SelectOption {
 interface ReferenceSelectProps extends Omit<AutocompleteProps, "options"> {
     options: ReferenceOption[];
 }
+/**
+ * Un choix parmi des objets métier, pas parmi des mots.
+ *
+ * Chaque option porte une description : deux clients peuvent s'appeler
+ * « Entreprise Alpha », et seule la ligne en dessous — la ville, le numéro
+ * de compte — dit lequel on vise.
+ */
 declare function ReferenceSelect({ options, ...props }: ReferenceSelectProps): react_jsx_runtime.JSX.Element;
 
 type FieldType = "text" | "textarea" | "email" | "password" | "phone" | "number" | "currency" | "date" | "time" | "datetime" | "select" | "multiselect" | "radio" | "checkbox" | "switch" | "file" | "image" | "slider" | "rating" | "color" | "rich-text" | "markdown" | "json" | "otp" | "tags" | "autocomplete" | "reference" | "hidden";
@@ -1191,104 +1649,841 @@ interface FieldProps {
     htmlFor?: string;
     orientation?: "vertical" | "horizontal";
     className?: string;
-    name?: string;
-    value?: FieldValue;
-    defaultValue?: FieldValue;
-    onValueChange?: (value: FieldValue) => void;
-    options?: SelectOption[];
-    referenceOptions?: ReferenceOption[];
-    controlLabel?: ReactNode;
-    placeholder?: string;
-    disabled?: boolean;
-    controlProps?: ControlProps;
-    children?: ReactElement<FieldControlProps>;
+    name?: string;
+    value?: FieldValue;
+    defaultValue?: FieldValue;
+    onValueChange?: (value: FieldValue) => void;
+    options?: SelectOption[];
+    referenceOptions?: ReferenceOption[];
+    controlLabel?: ReactNode;
+    placeholder?: string;
+    disabled?: boolean;
+    controlProps?: ControlProps;
+    children?: ReactElement<FieldControlProps>;
+}
+/**
+ * Le champ, et tout ce qui l'entoure.
+ *
+ * Un libellé, un contrôle, un message d'erreur, et les attributs qui les
+ * relient — `id`, `aria-describedby`, `aria-invalid`. Ce câblage est
+ * toujours le même et toujours oublié quelque part : ici il est fait une
+ * fois.
+ *
+ * `type` choisit le contrôle parmi les vingt-sept que la bibliothèque
+ * fournit. Le champ ne les réimplémente pas : il les monte et leur passe le
+ * branchement.
+ */
+declare function Field(rawProps: FieldProps): react_jsx_runtime.JSX.Element;
+
+/** Un champ du formulaire : les props de `Field`, plus sa place. */
+interface FormFieldConfig extends Omit<FieldProps, "field" | "name"> {
+    /** La clé dans les valeurs. C'est elle qui branche le champ. */
+    name: string;
+    /** Nombre de colonnes occupées. Ignoré sur une seule colonne. */
+    colSpan?: number;
+    rowSpan?: number;
+}
+/** Un groupe de champs, avec son titre et sa propre grille. */
+interface FormFieldGroup {
+    group: string;
+    description?: ReactNode;
+    columns?: number;
+    fields: FormFieldConfig[];
+}
+type FormEntry = FormFieldConfig | FormFieldGroup;
+/**
+ * Les valeurs qu'un formulaire déclaratif peut porter.
+ *
+ * Plus étroit que `FormValues` volontairement : ce formulaire rend ses
+ * champs avec `Field`, qui ne sait afficher que ces types-là. Un objet
+ * imbriqué n'aurait pas de contrôle pour le montrer.
+ */
+type FormShape = Record<string, FieldValue>;
+interface FormProps<TValues extends FormShape = FormShape> {
+    fields: FormEntry[];
+    /**
+     * L'adaptateur de formulaire.
+     *
+     * Sans lui, un `useLocalForm` est monté en interne à partir de
+     * `defaultValues`, `validate` et `onSubmit`. Avec lui — react-hook-form,
+     * Formik, votre propre magasin — le formulaire ne fait plus que rendre.
+     */
+    form?: FormAdapter<TValues>;
+    defaultValues?: TValues;
+    /** La validation. Un schéma Zod s'y branche en cinq lignes. */
+    validate?: FormValidator<TValues>;
+    onSubmit?: (values: TValues) => void | Promise<void>;
+    columns?: number;
+    submitText?: ReactNode;
+    clearText?: ReactNode;
+    showClear?: boolean;
+    submitProps?: ButtonProps;
+    /** Remplace entièrement la barre de boutons. */
+    actions?: ReactNode;
+    loading?: boolean;
+    /** Désactive l'envoi tant que rien n'a changé. */
+    requireDirty?: boolean;
+    /** Désactive l'envoi tant qu'une erreur est en vigueur. */
+    requireValid?: boolean;
+    className?: string;
+}
+/**
+ * Un formulaire décrit par ses champs.
+ *
+ * Il ne connaît aucune bibliothèque de formulaires : il reçoit un
+ * `FormAdapter`, ou en monte un lui-même. C'est ce qui lui permet de servir un
+ * projet sous react-hook-form et un projet sans rien, avec le même code.
+ *
+ * ```tsx
+ * <Form
+ *   columns={2}
+ *   defaultValues={{ nom: "", email: "" }}
+ *   validate={createValidator({ nom: [required()], email: [required(), email()] })}
+ *   onSubmit={(values) => api.post("/clients", { body: values })}
+ *   fields={[
+ *     { name: "nom", label: "Nom du client", required: true },
+ *     { name: "email", label: "Adresse e-mail", type: "email", required: true },
+ *   ]}
+ * />
+ * ```
+ */
+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;
+
+/**
+ * La description d'un objet métier, écrite une seule fois.
+ *
+ * Une page de liste décrit le même objet trois fois : en colonnes pour le
+ * tableau, en champs pour le formulaire, en lignes pour le détail. Plus la
+ * validation, les clés de recherche et la règle de droits par opération. Ces
+ * descriptions divergent, et toujours dans le même sens — c'est le formulaire
+ * qui oublie le champ que le tableau affiche.
+ *
+ * `defineResource` la décrit une fois; tout le reste en est dérivé. Ce module
+ * n'exporte donc pas de composant, mais les fonctions qui font cette
+ * dérivation : `CrudPage` les appelle, et chacune reste remplaçable par la
+ * prop correspondante.
+ */
+
+/**
+ * Une propriété d'une ressource.
+ *
+ * Elle est déclarée **une fois** et sert partout : colonne du tableau, champ
+ * du formulaire, ligne de la vue de détail, règle de validation, clé de
+ * recherche. C'est l'objet de toute cette déclaration — trois descriptions du
+ * même client finissent toujours par diverger, et c'est le formulaire qui
+ * oublie le champ que le tableau affiche.
+ */
+interface ResourceField<T = unknown> {
+    /** Le contrôle de saisie et le rendu par défaut. `text` sans précision. */
+    type?: FieldType;
+    /** À défaut, la clé de la propriété, première lettre en capitale. */
+    label?: ReactNode;
+    description?: ReactNode;
+    helpText?: ReactNode;
+    placeholder?: string;
+    required?: boolean;
+    /** Les règles en plus de `required`. Celles du type sont ajoutées seules. */
+    rules?: Array<Rule<never>>;
+    /** Les choix d'un `select`, `radio` ou `multiselect`. */
+    options?: SelectOption[];
+    /** Valeur de départ d'une création. */
+    defaultValue?: FieldValue;
+    /**
+     * Lu, mais pas saisi : un identifiant, une date de création, un total.
+     *
+     * Reste au tableau et au détail, disparaît du formulaire. Sans quoi une
+     * page de modification renverrait au serveur des champs qu'il calcule
+     * lui-même.
+     */
+    readOnly?: boolean;
+    /** Par défaut, tout sauf les types trop longs pour une cellule. */
+    inTable?: boolean;
+    /** Par défaut, tout sauf `readOnly`. */
+    inForm?: boolean;
+    /** Par défaut, tout. */
+    inDetail?: boolean;
+    /** Par défaut, les types textuels. */
+    searchable?: boolean;
+    sortable?: boolean;
+    align?: "start" | "center" | "end";
+    width?: string;
+    truncate?: boolean;
+    card?: ColumnCardRole;
+    /** Place du champ dans la grille du formulaire. */
+    colSpan?: number;
+    /** Le groupe de formulaire où ranger le champ. */
+    group?: string;
+    /** La devise d'un montant. */
+    currency?: string;
+    /** Le nombre de décimales d'un `number`. */
+    decimals?: number;
+    /**
+     * Le ton d'une valeur de `select`, par valeur.
+     *
+     * Déclaré, la colonne rend une pastille plutôt qu'un mot : un statut se lit
+     * alors d'un balayage, sans qu'on écrive une fonction de rendu.
+     */
+    tones?: Record<string, ComponentTone>;
+    /** Le rendu en tableau et en détail. Écrase celui déduit du type. */
+    render?: (row: T, index: number) => ReactNode;
+}
+interface ResourceDefinition<T> {
+    /** L'identifiant technique — sert aux droits et aux clés de cache. */
+    name: string;
+    /**
+     * Comment la ressource se nomme à l'écran.
+     *
+     * `create` est déclaré plutôt que fabriqué : « Nouvelle facture » et
+     * « Nouveau client » ne se déduisent pas du singulier sans connaître le
+     * genre, et se tromper une fois sur deux est pire que d'écrire « Créer ».
+     */
+    label?: {
+        singular?: ReactNode;
+        plural?: ReactNode;
+        create?: ReactNode;
+    };
+    description?: ReactNode;
+    /** La propriété qui identifie une ligne. `id` par défaut. */
+    key?: (keyof T & string) | ((row: T, index: number) => Key);
+    /** Les propriétés, dans l'ordre où elles s'affichent. */
+    fields: Record<string, ResourceField<T>>;
+    /**
+     * Les droits des quatre opérations.
+     *
+     * `"auto"` les dérive du nom : `facture.creer`, `facture.modifier`,
+     * `facture.supprimer`, `facture.lire`. C'est une convention, pas une
+     * obligation — chaque règle se déclare aussi à la main.
+     */
+    permissions?: "auto" | {
+        create?: PermissionRule;
+        view?: PermissionRule;
+        edit?: PermissionRule;
+        delete?: PermissionRule;
+    };
+    /** Colonnes de la grille du formulaire. */
+    formColumns?: number;
+}
+/**
+ * Déclarer une ressource.
+ *
+ * ```ts
+ * const factures = defineResource<Facture>({
+ *   name: "facture",
+ *   label: { singular: "Facture", plural: "Factures" },
+ *   fields: {
+ *     reference: { label: "Référence", required: true },
+ *     client: { label: "Client", required: true },
+ *     montant: { type: "currency", currency: "XOF", align: "end" },
+ *     statut: {
+ *       type: "select",
+ *       options: [{ value: "payee", label: "Payée" }],
+ *       tones: { payee: "success" },
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * La fonction ne transforme rien : elle sert à ce que TypeScript vérifie la
+ * déclaration au moment où on l'écrit, plutôt qu'au moment où on la passe à
+ * `CrudPage`. Le message d'erreur y gagne dix lignes de lisibilité.
+ */
+declare function defineResource<T>(definition: ResourceDefinition<T>): ResourceDefinition<T>;
+/** Les colonnes du tableau, dans l'ordre de déclaration. */
+declare function resourceColumns<T>(resource: ResourceDefinition<T>): Array<DataTableColumn<T>>;
+/**
+ * Les lignes de la vue de détail.
+ *
+ * Tenues à part des colonnes : une note de trois phrases n'a pas sa place
+ * dans une cellule, mais c'est précisément au détail qu'on va la lire. Les
+ * dériver du tableau priverait la vue de détail de tout ce qui est long, ce
+ * qui est exactement ce qu'elle existe pour montrer.
+ */
+declare function resourceDetailColumns<T>(resource: ResourceDefinition<T>): Array<DataTableColumn<T>>;
+/** Les champs du formulaire, groupés si la déclaration les groupe. */
+declare function resourceFormFields<T>(resource: ResourceDefinition<T>): FormEntry[];
+/**
+ * La validation, dérivée des types et des `required`.
+ *
+ * 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.
+ */
+declare function resourceValidator<T>(resource: ResourceDefinition<T>): 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. */
+declare function resourceDefaults<T>(resource: ResourceDefinition<T>): FormShape;
+/** Comment lire la clé d'une ligne. */
+declare function resourceRowKey<T>(resource: ResourceDefinition<T>): (row: T, index: number) => Key;
+/**
+ * Les droits des quatre opérations.
+ *
+ * `"auto"` applique la convention `<ressource>.<verbe>` — la seule chose
+ * qu'une convention doit faire : éviter d'écrire quatre fois ce qui se
+ * déduit une fois.
+ */
+declare function resourcePermissions<T>(resource: ResourceDefinition<T>): {
+    create?: PermissionRule;
+    view?: PermissionRule;
+    edit?: PermissionRule;
+    delete?: PermissionRule;
+};
+
+/** Laquelle des trois boîtes est ouverte, et sur quelle ligne. */
+interface CrudDialogState<T> {
+    mode: "create" | "edit" | "view";
+    row?: T;
+    index?: number;
+}
+/** Les titres et la forme des boîtes. Tout est facultatif. */
+interface CrudDialogOptions {
+    createTitle?: ReactNode;
+    createDescription?: ReactNode;
+    editTitle?: ReactNode;
+    editDescription?: ReactNode;
+    viewTitle?: ReactNode;
+    viewDescription?: ReactNode;
+    submitText?: ReactNode;
+    /** Colonnes du formulaire. Deux, au-delà de quatre ou cinq champs. */
+    columns?: number;
+    /** Colonnes de la vue de détail. */
+    detailColumns?: 1 | 2 | 3;
+}
+interface CrudDialogsProps<T> {
+    state: CrudDialogState<T> | null;
+    onClose: () => void;
+    columns: Array<DataTableColumn<T>>;
+    fields?: FormEntry[] | undefined;
+    validate?: FormValidator<FormShape> | undefined;
+    onSubmit?: ((values: FormShape, context: {
+        mode: "create" | "edit";
+        row?: T;
+        index?: number;
+    }) => void | Promise<void>) | undefined;
+    createDefaults?: FormShape | undefined;
+    toFormValues?: ((row: T) => FormShape) | undefined;
+    renderDetail?: ((row: T, index: number) => ReactNode) | undefined;
+    getRowKey?: ((row: T, index: number) => Key) | undefined;
+    dialog?: CrudDialogOptions | undefined;
+}
+/**
+ * Les boîtes du CRUD : créer, modifier, consulter.
+ *
+ * Elles n'inventent rien — `Modal` pour la boîte, `Form` pour la saisie,
+ * `Descriptions` pour la lecture. Ce qu'elles apportent est de savoir
+ * laquelle ouvrir, avec quelles valeurs, et de refermer une fois l'envoi
+ * passé.
+ */
+declare function CrudDialogs<T>({ state, onClose, columns, fields, validate, onSubmit, createDefaults, toFormValues, renderDetail, getRowKey, dialog, }: CrudDialogsProps<T>): react_jsx_runtime.JSX.Element;
+
+/**
+ * La personnalisation d'une action standard.
+ *
+ * Tout est facultatif : fournir le gestionnaire suffit à obtenir un bouton
+ * qui marche. Ce qui est ici ne sert qu'à s'écarter du défaut — un autre
+ * libellé, une règle de droits, une confirmation en plus ou en moins.
+ */
+interface CrudActionOptions<T> {
+    label?: ReactNode;
+    icon?: ReactNode;
+    permission?: PermissionRule;
+    hidden?: (row: T, index: number) => boolean;
+    disabled?: (row: T, index: number) => boolean;
+    /** `false` retire la confirmation que `delete` a par défaut. */
+    confirm?: RowAction<T>["confirm"] | false;
+}
+interface CrudCreateOptions {
+    label?: ReactNode;
+    icon?: ReactNode;
+    permission?: PermissionRule;
+    disabled?: boolean;
+}
+interface CrudPageBase<T> {
+    /** À défaut, le pluriel de la ressource. */
+    title?: ReactNode;
+    description?: ReactNode;
+    eyebrow?: ReactNode;
+    data: T[];
+    getRowKey?: (row: T, index: number) => Key;
+    /**
+     * Ce que fait le bouton de création.
+     *
+     * Facultatif : avec `fields`, la page ouvre elle-même son formulaire. Le
+     * fournir sert à partir ailleurs — une page dédiée, un assistant en
+     * plusieurs étapes — et prend alors le pas sur la boîte.
+     */
+    onCreate?: () => void;
+    /** Idem : sans lui, la boîte de détail s'ouvre. */
+    onView?: (row: T, index: number) => void;
+    /** Idem : sans lui, le formulaire s'ouvre prérempli. */
+    onEdit?: (row: T, index: number) => void;
+    /** Confirmée d'office. Détruire sans demander est une faute. */
+    onDelete?: (row: T, index: number) => void | Promise<void>;
+    /**
+     * Les champs de création et de modification.
+     *
+     * Les déclarer suffit à obtenir un CRUD complet : le bouton « Créer » ouvre
+     * un formulaire vide, « Modifier » le même prérempli, « Consulter » la
+     * ligne en lecture. C'est la même description que `Form` — aucun schéma
+     * propre à cette page, aucune bibliothèque imposée.
+     */
+    fields?: FormEntry[];
+    /** Ce que la page fait d'un formulaire envoyé. */
+    onSubmit?: (values: FormShape, context: {
+        mode: "create" | "edit";
+        row?: T;
+        index?: number;
+    }) => void | Promise<void>;
+    /**
+     * La validation, sous la même forme que `Form`.
+     *
+     * `createValidator` de `@sia-ui/utils/validation` en produit une; un Zod s'y
+     * branche en cinq lignes, sans que le composant connaisse Zod.
+     */
+    validate?: FormValidator<FormShape>;
+    /** Valeurs de départ d'une création. Par défaut, des champs vides. */
+    createDefaults?: FormShape;
+    /**
+     * Comment une ligne devient des valeurs de formulaire.
+     *
+     * Par défaut, les champs de même nom sont repris tels quels. À fournir dès
+     * que la ligne et le formulaire ne parlent pas la même langue — une date
+     * ISO à découper, un objet lié à réduire à son identifiant.
+     */
+    toFormValues?: (row: T) => FormShape;
+    /**
+     * La vue de détail.
+     *
+     * Par défaut dérivée des colonnes, qui disent déjà quoi montrer. Une
+     * fonction la remplace, `false` la retire avec son action.
+     */
+    detail?: boolean | ((row: T, index: number) => ReactNode);
+    /** Titres, largeur et nombre de colonnes des boîtes. */
+    dialog?: CrudDialogOptions;
+    /**
+     * De quoi s'écarter des défauts.
+     *
+     * `false` retire une action alors même que son gestionnaire existe — utile
+     * quand le gestionnaire sert ailleurs, par exemple à un raccourci clavier.
+     */
+    operations?: {
+        create?: CrudCreateOptions | false;
+        view?: CrudActionOptions<T> | false;
+        edit?: CrudActionOptions<T> | false;
+        delete?: CrudActionOptions<T> | false;
+    };
+    /** Des actions de ligne en plus des quatre standard. */
+    extraRowActions?: Array<RowAction<T>> | ((row: T, index: number) => Array<RowAction<T>>);
+    /** Suppression groupée. Ajoute la sélection et sa barre d'actions. */
+    onBulkDelete?: (keys: Key[], rows: T[]) => void | Promise<void>;
+    can?: (rule: PermissionRule) => boolean;
+    /** Actions de page, à droite du titre. S'ajoute au bouton de création. */
+    headerActions?: ReactNode;
+    toolbar?: ReactNode;
+    searchKeys?: string[];
+    searchPlaceholder?: string;
+    onSearch?: (query: string) => void;
+    loading?: boolean;
+    error?: ReactNode;
+    onRetry?: () => void;
+    empty?: DataTableProps<T>["empty"];
+    page?: number;
+    totalPages?: number;
+    onPageChange?: (page: number) => void;
+    /**
+     * Ce qui n'a pas de raccourci ici passe au tableau tel quel — densité,
+     * mode cartes, tri, colonnes figées.
+     */
+    table?: Partial<Omit<DataTableProps<T>, "columns" | "data">>;
+    /** Remplace le tableau. Le reste de la page continue de fonctionner. */
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * Les props de la page.
+ *
+ * Deux façons de la remplir, et une seule des deux à la fois : une ressource
+ * déclarée, d'où tout se déduit, ou des colonnes écrites à la main. L'union
+ * 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> & ({
+    /**
+     * La ressource, déclarée une fois avec `defineResource`.
+     *
+     * Colonnes, formulaire, détail, validation, recherche, clé de ligne
+     * et droits en sont dérivés. Chacun reste remplaçable — `columns`,
+     * `fields`, `validate`, `searchKeys` passent devant la dérivation.
+     */
+    resource: ResourceDefinition<T>;
+    columns?: Array<DataTableColumn<T>>;
+} | {
+    resource?: undefined;
+    columns: Array<DataTableColumn<T>>;
+});
+/**
+ * Une page de liste, avec ses quatre opérations.
+ *
+ * Créer, consulter, modifier, supprimer : ce sont les mêmes partout, et les
+ * réécrire à chaque écran produit quatre variantes qui divergent — celle qui
+ * oublie la confirmation, celle qui ne vérifie pas les droits, celle dont le
+ * bouton ne se désactive pas pendant l'appel.
+ *
+ * Ici, fournir le gestionnaire suffit. Ne pas le fournir retire l'action.
+ */
+declare function CrudPage<T>({ resource, title, description, eyebrow, 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, loading, error, onRetry, empty, page, totalPages, onPageChange, table, children, className, }: CrudPageProps<T>): react_jsx_runtime.JSX.Element;
+
+/**
+ * L'état du tableau dans la barre d'adresse.
+ *
+ * `history.replaceState` plutôt que `pushState` : trier une colonne trois
+ * fois de suite ne doit pas demander trois retours en arrière pour revenir
+ * d'où l'on vient.
+ */
+declare function createUrlTableStorage(mode?: "replace" | "push"): TableQueryStorage;
+interface UseDataTableQueryOptions {
+    defaultState?: Partial<TableQueryState>;
+    /** `false` garde l'état en mémoire — utile dans une modale. */
+    syncUrl?: boolean;
+    /** Empile une entrée d'historique à chaque changement. */
+    history?: "replace" | "push";
+    /** Préfixe des clés, pour deux tableaux sur la même page. */
+    prefix?: string;
+}
+/**
+ * Tri, filtres et pagination d'un tableau, synchronisés avec l'URL.
+ *
+ * Le calcul vit dans `@sia-ui/headless`; il n'y a ici que le branchement sur
+ * la barre d'adresse, qui est la seule partie propre au navigateur.
+ */
+declare function useDataTableQuery(options?: UseDataTableQueryOptions): TableQuery;
+
+/**
+ * Un tableau de données.
+ *
+ * Il n'ordonne rien lui-même : à partir de quelques centaines de lignes,
+ * trier côté client veut dire les avoir toutes téléchargées. Le tri est une
+ * intention envoyée au serveur, et le tableau affiche ce qu'on lui rend.
+ *
+ * La recherche fait exception, et seulement par défaut : sans `onSearch`,
+ * 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, 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;
+
+type DateRangeValue = CalendarRangeValue;
+interface DateRangePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek" | "disabledDate" | "cellRender" | "showWeek"> {
+    value?: DateRangeValue;
+    defaultValue?: DateRangeValue;
+    onValueChange?: (value: DateRangeValue) => void;
+    min?: string;
+    max?: string;
+    startLabel?: string;
+    endLabel?: string;
+    allowClear?: boolean;
+    placement?: OverlayPlacement;
+    tone?: ComponentTone;
+    invalid?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+/**
+ * Un début et une fin, choisis ensemble.
+ *
+ * Deux champs séparés laissent poser une fin antérieure au début, et il
+ * 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;
+
+interface DateRangePreset {
+    label: ReactNode;
+    value: DateRangeValue;
+}
+interface DateRangeFilterProps {
+    value: DateRangeValue;
+    onValueChange: (value: DateRangeValue) => void;
+    presets?: DateRangePreset[];
+    onClear?: () => void;
+    className?: string;
+}
+/**
+ * Une période, avec ses raccourcis.
+ *
+ * Les périodes utiles se comptent sur une main — ce mois, le trimestre,
+ * 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;
+
+interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: "horizontal" | "vertical";
+    decorative?: boolean;
+}
+/**
+ * Un trait entre deux choses.
+ *
+ * `decorative` décide s'il compte pour un lecteur d'écran. Un trait qui
+ * sépare deux groupes de sens est une information; un trait qui aère ne
+ * l'est pas, et l'annoncer ajoute du bruit à chaque parcours.
+ */
+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;
+    locale?: string;
+    style?: "short" | "long" | "clock";
+    className?: string;
 }
-declare function Field(rawProps: FieldProps): react_jsx_runtime.JSX.Element;
+/**
+ * Une durée, en mots ou en pendule.
+ *
+ * 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 FiltersBarProps {
-    search?: ReactNode;
-    filters?: ReactNode;
-    actions?: ReactNode;
-    activeCount?: number;
-    onReset?: () => void;
-    resetLabel?: string;
+interface EmptyStateProps {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    compact?: boolean;
     className?: string;
 }
-declare function FiltersBar({ search, filters, actions, activeCount, onReset, resetLabel: resetLabelProp, className }: FiltersBarProps): react_jsx_runtime.JSX.Element;
+/**
+ * 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;
 
-/** Un champ du formulaire : les props de `Field`, plus sa place. */
-interface FormFieldConfig extends Omit<FieldProps, "field" | "name"> {
-    /** La clé dans les valeurs. C'est elle qui branche le champ. */
-    name: string;
-    /** Nombre de colonnes occupées. Ignoré sur une seule colonne. */
-    colSpan?: number;
-    rowSpan?: number;
+interface EntityMetaProps {
+    createdAt?: Date | string | number;
+    updatedAt?: Date | string | number;
+    createdBy?: ReactNode;
+    updatedBy?: ReactNode;
+    identifier?: string;
+    status?: ReactNode;
+    locale?: string;
+    className?: string;
 }
-/** Un groupe de champs, avec son titre et sa propre grille. */
-interface FormFieldGroup {
-    group: string;
+/**
+ * Les traces d'un objet : créé le, modifié par, identifiant.
+ *
+ * L'identifiant est normalisé pour être lu à voix haute au téléphone —
+ * 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;
+
+interface ErrorStateProps {
+    title?: ReactNode;
     description?: ReactNode;
-    columns?: number;
-    fields: FormFieldConfig[];
+    error?: unknown;
+    action?: ReactNode;
+    onRetry?: () => void;
+    retryLabel?: string;
+    compact?: boolean;
+    className?: string;
 }
-type FormEntry = FormFieldConfig | FormFieldGroup;
 /**
- * Les valeurs qu'un formulaire déclaratif peut porter.
+ * Un échec, et de quoi en sortir.
  *
- * Plus étroit que `FormValues` volontairement : ce formulaire rend ses
- * champs avec `Field`, qui ne sait afficher que ces types-là. Un objet
- * imbriqué n'aurait pas de contrôle pour le montrer.
+ * `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.
  */
-type FormShape = Record<string, FieldValue>;
-interface FormProps<TValues extends FormShape = FormShape> {
-    fields: FormEntry[];
-    /**
-     * L'adaptateur de formulaire.
-     *
-     * Sans lui, un `useLocalForm` est monté en interne à partir de
-     * `defaultValues`, `validate` et `onSubmit`. Avec lui — react-hook-form,
-     * Formik, votre propre magasin — le formulaire ne fait plus que rendre.
-     */
-    form?: FormAdapter<TValues>;
-    defaultValues?: TValues;
-    /** La validation. Un schéma Zod s'y branche en cinq lignes. */
-    validate?: FormValidator<TValues>;
-    onSubmit?: (values: TValues) => void | Promise<void>;
-    columns?: number;
-    submitText?: ReactNode;
-    clearText?: ReactNode;
-    showClear?: boolean;
-    submitProps?: ButtonProps;
-    /** Remplace entièrement la barre de boutons. */
+declare function ErrorState({ title: titleProp, description, error, action, onRetry, retryLabel: retryLabelProp, compact, className }: ErrorStateProps): react_jsx_runtime.JSX.Element;
+
+interface CalendarEvent {
+    id: string;
+    date: string;
+    title: string;
+    tone?: ComponentTone;
+}
+interface EventCalendarProps extends Omit<CalendarProps, "renderDay"> {
+    events: CalendarEvent[];
+    maxEventsPerDay?: number;
+    onEventClick?: (event: CalendarEvent) => void;
+}
+/**
+ * Un calendrier qui porte des événements.
+ *
+ * `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.
+ */
+declare function EventCalendar({ events, maxEventsPerDay, onEventClick, ...props }: EventCalendarProps): react_jsx_runtime.JSX.Element;
+
+interface FiltersBarProps {
+    search?: ReactNode;
+    filters?: ReactNode;
     actions?: ReactNode;
-    loading?: boolean;
-    /** Désactive l'envoi tant que rien n'a changé. */
-    requireDirty?: boolean;
-    /** Désactive l'envoi tant qu'une erreur est en vigueur. */
-    requireValid?: boolean;
+    activeCount?: number;
+    onReset?: () => void;
+    resetLabel?: string;
     className?: string;
 }
 /**
- * Un formulaire décrit par ses champs.
- *
- * Il ne connaît aucune bibliothèque de formulaires : il reçoit un
- * `FormAdapter`, ou en monte un lui-même. C'est ce qui lui permet de servir un
- * projet sous react-hook-form et un projet sans rien, avec le même code.
+ * La barre au-dessus d'une liste : recherche, filtres, actions.
  *
- * ```tsx
- * <Form
- *   columns={2}
- *   defaultValues={{ nom: "", email: "" }}
- *   validate={createValidator({ nom: [required()], email: [required(), email()] })}
- *   onSubmit={(values) => api.post("/clients", { body: values })}
- *   fields={[
- *     { name: "nom", label: "Nom du client", required: true },
- *     { name: "email", label: "Adresse e-mail", type: "email", required: true },
- *   ]}
- * />
- * ```
+ * `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.
  */
-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 FiltersBar({ search, filters, actions, activeCount, onReset, resetLabel: resetLabelProp, className }: FiltersBarProps): react_jsx_runtime.JSX.Element;
 
 interface HoverCardProps {
     content: ReactNode;
@@ -1326,6 +2521,14 @@ interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     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>>;
 
 type IconProps = SVGProps<SVGSVGElement>;
@@ -1377,6 +2580,13 @@ declare const InputNumber: react.ForwardRefExoticComponent<InputNumberProps & re
 interface KpiGridProps extends HTMLAttributes<HTMLDivElement> {
     columns?: 1 | 2 | 3 | 4;
 }
+/**
+ * Une rangée d'indicateurs.
+ *
+ * Le nombre de colonnes est déclaré, pas déduit du nombre de cartes : trois
+ * indicateurs sur quatre colonnes laissent un trou, et ce trou dit qu'il
+ * manque une donnée.
+ */
 declare function KpiGrid({ columns, className, ...props }: KpiGridProps): react_jsx_runtime.JSX.Element;
 
 interface LabelProps extends react.LabelHTMLAttributes<HTMLLabelElement> {
@@ -1389,8 +2599,22 @@ interface LabelProps extends react.LabelHTMLAttributes<HTMLLabelElement> {
 }
 /** Alias historique, attendu par les composants venus du registre. */
 type ILabelProps = LabelProps;
+/**
+ * Le nom d'un champ.
+ *
+ * L'astérisque d'obligation est portée par une prop plutôt qu'écrite dans
+ * le texte : elle reçoit ainsi un `aria-hidden`, et le champ est annoncé
+ * « obligatoire » plutôt que « nom étoile ».
+ */
 declare const Label: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLLabelElement>>;
 
+/**
+ * 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 MiniCalendar({ className, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
 
 interface ModalProps {
@@ -1404,12 +2628,27 @@ interface ModalProps {
     closeLabel?: string;
     className?: string;
 }
+/**
+ * Une boîte qui interrompt.
+ *
+ * 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 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;
 }
+/**
+ * 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 {
@@ -1419,6 +2658,13 @@ interface PageHeaderProps {
     actions?: ReactNode;
     className?: string;
 }
+/**
+ * Le titre d'un écran, et ses actions.
+ *
+ * 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.
+ */
 declare function PageHeader({ title, description, eyebrow, actions, className }: PageHeaderProps): react_jsx_runtime.JSX.Element;
 
 interface PaginationProps {
@@ -1482,6 +2728,12 @@ interface PermissionGateProps {
     fallback?: ReactNode;
     children: ReactNode;
 }
+/**
+ * Ce qui n'apparaît qu'avec le droit correspondant.
+ *
+ * > Ceci masque une portion d'écran; **ça ne protège pas une API**. Le
+ * > serveur reste seul juge, et doit refuser la même chose.
+ */
 declare function PermissionGate({ permissions, require, mode, fallback, children }: PermissionGateProps): react_jsx_runtime.JSX.Element;
 
 interface PhoneCountry {
@@ -1546,6 +2798,13 @@ interface PopoverProps {
     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 {
@@ -1579,6 +2838,13 @@ interface QRCodeProps {
     render?: (value: string, size: number) => ReactNode;
     className?: string;
 }
+/**
+ * Un code à scanner.
+ *
+ * Le rendu est délégué à `render` : embarquer un encodeur ajouterait une
+ * 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;
 
 interface RelativeTimeProps extends Omit<HTMLAttributes<HTMLTimeElement>, "dateTime"> {
@@ -1587,6 +2853,12 @@ interface RelativeTimeProps extends Omit<HTMLAttributes<HTMLTimeElement>, "dateT
     prefix?: string;
     refreshInterval?: number;
 }
+/**
+ * Une date, dite par rapport à maintenant.
+ *
+ * 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;
 
 interface RequireSessionProps<TUser, TTenant, TRule> {
@@ -1655,6 +2927,13 @@ interface ResizablePanelProps {
     direction?: "horizontal" | "vertical";
     className?: string;
 }
+/**
+ * Deux zones, et une poignée entre elles.
+ *
+ * Les bornes `minSize` et `maxSize` empêchent de réduire un panneau à
+ * rien : une zone à zéro pour cent disparaît avec sa poignée, et on ne peut
+ * plus la rouvrir.
+ */
 declare function ResizablePanel({ first, second, defaultSize, minSize, maxSize, direction, className }: ResizablePanelProps): react_jsx_runtime.JSX.Element;
 
 interface ScrollAreaProps {
@@ -1698,46 +2977,15 @@ interface SearchInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "
     searchLabel?: string;
     clearLabel?: string;
 }
-declare const SearchInput: react.ForwardRefExoticComponent<SearchInputProps & react.RefAttributes<HTMLInputElement>>;
-
-interface SidebarItem {
-    key: string;
-    label: ReactNode;
-    icon?: ReactNode;
-    /** Rend l'entrée comme un lien. Sans lui, c'est un bouton. */
-    href?: string;
-    badge?: ReactNode;
-    disabled?: boolean;
-    /** Sous-entrées. Une seule profondeur : au-delà, c'est un menu, pas une barre. */
-    items?: Array<Omit<SidebarItem, "items">>;
-    onClick?: () => void;
-}
-interface SidebarSection {
-    key: string;
-    /** Le titre du groupe. Masqué en mode réduit. */
-    title: ReactNode;
-    items: SidebarItem[];
-}
-type SidebarEntry = SidebarItem | SidebarSection;
-interface SidebarProps {
-    items: SidebarEntry[];
-    /** La clé de l'entrée courante. Un parent s'ouvre si un enfant l'est. */
-    activeKey?: string;
-    collapsed?: boolean;
-    header?: ReactNode;
-    footer?: ReactNode;
-    onNavigate?: (item: SidebarItem) => void;
-    ariaLabel?: string;
-    className?: string;
-}
 /**
- * La navigation principale.
+ * Une recherche, avec son délai.
  *
- * Elle se pose dans le `navigation` d'`AppShell`, qui gère déjà la largeur et
- * le repli. Ici, seulement les entrées : ce qui est actif, ce qui est ouvert,
- * ce qui se replie en icônes.
+ * `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 function Sidebar({ items, activeKey, collapsed, header, footer, onNavigate, ariaLabel, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+declare const SearchInput: react.ForwardRefExoticComponent<SearchInputProps & react.RefAttributes<HTMLInputElement>>;
 
 interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
     width?: CSSProperties["width"];
@@ -1745,6 +2993,13 @@ interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
     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 {
@@ -1759,6 +3014,13 @@ interface StatisticProps {
     trend?: number;
     className?: string;
 }
+/**
+ * Un nombre qu'on lit d'un coup d'œil.
+ *
+ * La tendance est un écart, pas une flèche : c'est le signe du nombre qui
+ * 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;
 
 interface StatCardProps extends StatisticProps {
@@ -1766,6 +3028,13 @@ interface StatCardProps extends StatisticProps {
     description?: ReactNode;
     action?: ReactNode;
 }
+/**
+ * Un indicateur, dans une carte.
+ *
+ * L'assemblage d'une `Card` et d'un `Statistic` — la forme qu'ils prennent
+ * 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";
@@ -1803,6 +3072,13 @@ interface TabsProps {
     className?: string;
     children: ReactNode;
 }
+/**
+ * Des vues qui se remplacent au même endroit.
+ *
+ * Elles servent à des contenus de même rang — jamais à des étapes, qui ont
+ * un ordre et des `Steps`, ni à une navigation entre écrans, qui change
+ * l'adresse.
+ */
 declare function Tabs({ value, defaultValue, onValueChange, className, children }: TabsProps): react_jsx_runtime.JSX.Element;
 declare function TabsList({ className, children }: {
     className?: string;
@@ -1835,6 +3111,12 @@ interface TimeRangePickerProps extends Pick<TimePickerProps, "minuteStep" | "sec
     disabled?: boolean;
     className?: string;
 }
+/**
+ * Une heure de début et une heure de fin.
+ *
+ * `order` impose que la fin suive le début. On peut le lever — une garde
+ * de nuit finit le lendemain — mais il faut l'avoir écrit.
+ */
 declare function TimeRangePicker({ value, defaultValue, onValueChange, order, startLabel: startLabelProp, endLabel: endLabelProp, minuteStep, secondStep, showSeconds, hourFormat, needConfirm, allowClear, tone, invalid, disabled, className }: TimeRangePickerProps): react_jsx_runtime.JSX.Element;
 
 interface TimelineItem {
@@ -1849,6 +3131,13 @@ interface TimelineProps {
     pending?: ReactNode;
     className?: string;
 }
+/**
+ * Une suite d'événements, dans l'ordre.
+ *
+ * Le ton porte le sens de chaque étape : une chronologie de paiement se lit
+ * d'abord par ses couleurs — ce qui a abouti, ce qui a échoué — avant qu'on
+ * en lise les libellés.
+ */
 declare function Timeline({ items, pending, className }: TimelineProps): react_jsx_runtime.JSX.Element;
 
 interface ToasterProps {
@@ -1974,6 +3263,13 @@ interface TourProps {
     onStepChange?: (step: number) => void;
     className?: string;
 }
+/**
+ * Une visite guidée de l'écran.
+ *
+ * Chaque étape vise un élément par son sélecteur plutôt que par une
+ * référence : une visite se déclare souvent loin des composants qu'elle
+ * montre, et parfois avant qu'ils n'existent.
+ */
 declare function Tour({ open, onOpenChange, steps, initialStep, onStepChange, className }: TourProps): react.ReactPortal | null;
 
 interface TransferItem {
@@ -1989,6 +3285,13 @@ interface TransferProps {
     targetTitle?: string;
     className?: string;
 }
+/**
+ * Deux listes, et ce qui passe de l'une à l'autre.
+ *
+ * La forme qui convient quand le choix se compte en dizaines : une liste à
+ * 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;
 
 interface TreeNode {
@@ -2004,6 +3307,13 @@ interface TreeProps {
     onSelect?: ((node: TreeNode) => void) | undefined;
     className?: string;
 }
+/**
+ * Une arborescence qu'on déplie.
+ *
+ * Les branches ouvertes sont un état à part de la sélection : replier un
+ * nœud ne désélectionne pas ce qu'il contient, et rouvrir l'écran ne doit
+ * pas tout refermer.
+ */
 declare function Tree({ nodes, defaultExpandedKeys, selectedKey, onSelect, className }: TreeProps): react_jsx_runtime.JSX.Element;
 
 interface TreeSelectProps {
@@ -2013,12 +3323,27 @@ interface TreeSelectProps {
     placeholder?: string;
     className?: string;
 }
+/**
+ * Un choix dans une arborescence.
+ *
+ * Là où une liste plate perdrait le chemin : « Ventes › Règlements › En
+ * 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;
 
 interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
     level?: 1 | 2 | 3 | 4 | 5 | 6;
     size?: "sm" | "md" | "lg" | "xl";
 }
+/**
+ * Un titre.
+ *
+ * Le niveau et la taille sont deux props distinctes : le niveau dit la
+ * place dans la hiérarchie du document, la taille ce qu'on voit. Les lier
+ * forcerait à sauter un niveau pour obtenir un titre plus petit — et à
+ * casser le parcours au lecteur d'écran.
+ */
 declare function Heading({ level, size, className, ...props }: HeadingProps): react_jsx_runtime.JSX.Element;
 interface TextProps extends HTMLAttributes<HTMLParagraphElement> {
     tone?: ComponentTone;
@@ -2031,6 +3356,14 @@ interface UnsavedChangesGuardProps {
     when: boolean;
     message?: string;
 }
+/**
+ * L'avertissement avant de quitter une saisie en cours.
+ *
+ * Le navigateur n'autorise cette interruption que sur un geste explicite de
+ * quitter, et impose son propre libellé : le message passé ici sert à la
+ * confirmation interne, que `confirmUnsavedNavigation` déclenche avant une
+ * navigation du routeur.
+ */
 declare function UnsavedChangesGuard({ when, message }: UnsavedChangesGuardProps): null;
 declare function confirmUnsavedNavigation(when: boolean, message?: string): boolean;
 
@@ -2038,6 +3371,13 @@ interface WeekPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "t
     onValueChange?: (value: string) => void;
     invalid?: boolean;
 }
+/**
+ * Une semaine, désignée par son numéro.
+ *
+ * Le numéro de semaine est l'unité des plannings et des relevés d'activité,
+ * et il ne se déduit pas d'une date sans convention — celle du navigateur
+ * est celle de la norme ISO.
+ */
 declare const WeekPicker: react.ForwardRefExoticComponent<WeekPickerProps & react.RefAttributes<HTMLInputElement>>;
 
 interface YearPickerProps {
@@ -2048,6 +3388,13 @@ interface YearPickerProps {
     onValueChange?: (year: number) => void;
     className?: string;
 }
+/**
+ * Une année, choisie dans une plage.
+ *
+ * Les bornes sont déclarées parce qu'elles dépendent du sujet : une année
+ * d'exercice comptable et une année de naissance n'ouvrent pas la même
+ * liste.
+ */
 declare function YearPicker({ value, defaultValue, min, max, onValueChange, className }: YearPickerProps): react_jsx_runtime.JSX.Element;
 
-export { Accordion, type AccordionItem, type AccordionProps, Alert, AlertCircleIcon, type AlertProps, AmountDisplay, type AmountDisplayProps, AppShell, type AppShellProps, ArrowRightIcon, AspectRatio, type AspectRatioProps, AsyncState, type AsyncStateProps, type AuditEvent, AuditMeta, type AuditMetaProps, AuthLayout, type AuthLayoutProps, Autocomplete, type AutocompleteProps, Avatar, type AvatarProps, Badge, type BadgeProps, 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 CommandItem, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, Container, ContextMenu, type ContextMenuProps, Countdown, type CountdownProps, CrudPage, type CrudPageProps, CurrencyInput, type CurrencyInputProps, DEFAULT_COUNTRIES, DataTable, type DataTableColumn, type DataTableProps, 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, Form, type FormEntry, Field as FormField, type FormFieldConfig, type FormFieldGroup, type FieldProps as FormFieldProps, type FormProps, type FormShape, Heading, type HeadingProps, 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, KpiGrid, type KpiGridProps, Label, type LabelProps, 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, Pagination, type PaginationProps, PasswordInput, type PasswordInputProps, type PasswordStrength, 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, RichTextEditor, type RichTextEditorProps, ScrollArea, type ScrollAreaProps, SearchIcon, SearchInput, type SearchInputProps, Select, type SelectOption, type SelectProps, Sidebar, type SidebarEntry, type SidebarItem, type SidebarProps, type SidebarSection, Skeleton, type SkeletonProps, Slider, type SliderProps, type SliderRangeValue, Sparkline, type SparklineProps, Spinner, type SpinnerProps, Stack, StarIcon, StatCard, type StatCardProps, Statistic, type StatisticProps, type StepItem, type StepStatus, Steps, type StepsProps, Switch, type SwitchProps, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, TagsInput, type TagsInputProps, 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, WeekPicker, type WeekPickerProps, XIcon, YearPicker, type YearPickerProps, confirmUnsavedNavigation, createUrlTableStorage, formatDuration, formatTimeValue, parseTimeValue, useDataTableQuery, useToast };
+export { Accordion, type AccordionItem, type AccordionProps, Alert, AlertCircleIcon, type AlertProps, AmountDisplay, type AmountDisplayProps, AppShell, type AppShellCollapsible, type AppShellContentWidth, type AppShellMobileNav, type AppShellProps, 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, 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, Form, type FormEntry, Field as FormField, type FormFieldConfig, type FormFieldGroup, type FieldProps as FormFieldProps, type FormProps, type FormShape, Heading, type HeadingProps, 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, KpiGrid, type KpiGridProps, Label, type LabelProps, 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, Pagination, type PaginationProps, PasswordInput, type PasswordInputProps, type PasswordStrength, 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, RichTextEditor, type RichTextEditorProps, type RowAction, ScrollArea, type ScrollAreaProps, SearchIcon, SearchInput, type SearchInputProps, Select, type SelectOption, type SelectProps, 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, type StepItem, type StepStatus, Steps, type StepsProps, Switch, type SwitchProps, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, TagsInput, type TagsInputProps, 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, WeekPicker, type WeekPickerProps, XIcon, YearPicker, type YearPickerProps, confirmUnsavedNavigation, createUrlTableStorage, defineResource, formatDuration, formatTimeValue, initialsOf, parseTimeValue, resourceColumns, resourceDefaults, resourceDetailColumns, resourceFormFields, resourcePermissions, resourceRowKey, resourceSearchKeys, resourceValidator, tintForName, useDataTableQuery, useToast };