@sia-ui/react-web 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2053 @@
+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 { 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';
+export { SliderValue, ToastId, ToastOptions, ToastPlacement, ToastTone, toast, toastStore } from '@sia-ui/headless';
+
+interface AccordionItem {
+    key: string;
+    title: ReactNode;
+    content: ReactNode;
+    /** Une ligne sous le titre, visible même replié. */
+    description?: ReactNode;
+    icon?: ReactNode;
+    /** À droite du titre : un compteur, un badge, un statut. */
+    meta?: ReactNode;
+    disabled?: boolean;
+}
+interface AccordionProps {
+    items: AccordionItem[];
+    /** `single` referme la section précédente, `multiple` les cumule. */
+    type?: "single" | "multiple";
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    /** En `single`, autorise à tout refermer. */
+    collapsible?: boolean;
+    variant?: "bordered" | "separated" | "plain";
+    className?: string;
+}
+/**
+ * Des sections dépliables.
+ *
+ * La hauteur s'anime sans être mesurée : le panneau est une grille dont la
+ * ligne passe de `0fr` à `1fr`. Pas de `scrollHeight`, pas de recalcul au
+ * redimensionnement, et un contenu qui change de taille suit tout seul.
+ */
+declare function Accordion({ items, type, value, defaultValue, onValueChange, collapsible, variant, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
+interface CollapseProps {
+    title: ReactNode;
+    children: ReactNode;
+    description?: ReactNode;
+    meta?: ReactNode;
+    icon?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    variant?: AccordionProps["variant"];
+    disabled?: boolean;
+    className?: string;
+}
+/** Une section seule. Le même rendu, pour le cas le plus courant. */
+declare function Collapse({ title, children, description, meta, icon, open, defaultOpen, onOpenChange, variant, disabled, className, }: CollapseProps): react_jsx_runtime.JSX.Element;
+
+interface AlertProps {
+    tone?: ComponentTone;
+    title?: ReactNode;
+    children?: ReactNode;
+    action?: ReactNode;
+    dismissLabel?: string;
+    onDismiss?: () => void;
+    className?: string;
+}
+declare function Alert({ tone, title, children, action, dismissLabel: dismissLabelProp, onDismiss, className }: AlertProps): react_jsx_runtime.JSX.Element;
+
+interface AmountDisplayProps {
+    value: number;
+    currency?: string;
+    locale?: string;
+    label?: ReactNode;
+    secondary?: ReactNode;
+    sign?: "auto" | "always";
+    tone?: ComponentTone;
+    className?: string;
+}
+declare function AmountDisplay({ value, currency, locale, label, secondary, sign, tone, className }: AmountDisplayProps): react_jsx_runtime.JSX.Element;
+
+interface AppShellProps {
+    logo?: ReactNode;
+    navigation: ReactNode;
+    header?: ReactNode;
+    children: ReactNode;
+    footer?: ReactNode;
+    defaultCollapsed?: boolean;
+    className?: string;
+}
+declare function AppShell({ logo, navigation, header, children, footer, defaultCollapsed, className }: AppShellProps): react_jsx_runtime.JSX.Element;
+
+interface AspectRatioProps {
+    /** Le rapport largeur / hauteur. `16 / 9`, `1`, `4 / 3`. */
+    ratio?: number;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Une boîte au rapport imposé.
+ *
+ * Elle existe pour une seule raison : réserver la place avant que l'image ou
+ * l'iframe n'arrive. Sans elle, le contenu qui suit saute au chargement — ce
+ * que mesure le Cumulative Layout Shift, et ce que les gens ressentent comme
+ * une page qui bouge sous le doigt.
+ */
+declare function AspectRatio({ ratio, children, className }: AspectRatioProps): react_jsx_runtime.JSX.Element;
+
+interface AsyncStateProps {
+    loading?: boolean;
+    error?: ReactNode;
+    empty?: boolean;
+    emptyTitle?: ReactNode;
+    emptyDescription?: ReactNode;
+    onRetry?: () => void;
+    children: ReactNode;
+}
+declare function AsyncState({ loading, error, empty, emptyTitle, emptyDescription, onRetry, children }: AsyncStateProps): react_jsx_runtime.JSX.Element;
+
+interface AuditEvent {
+    label: ReactNode;
+    at: Date | string | number;
+    by?: ReactNode;
+    detail?: ReactNode;
+}
+interface AuditMetaProps {
+    events: AuditEvent[];
+    locale?: string;
+    title?: ReactNode;
+    emptyLabel?: ReactNode;
+    className?: string;
+}
+declare function AuditMeta({ events, locale, title, emptyLabel, className }: AuditMetaProps): react_jsx_runtime.JSX.Element;
+
+interface AuthLayoutProps {
+    title: ReactNode;
+    description?: ReactNode;
+    logo?: ReactNode;
+    aside?: ReactNode;
+    children: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+}
+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";
+interface OverlayProps {
+    open: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    placement?: OverlayPlacement;
+    offset?: number;
+    matchAnchorWidth?: boolean;
+    viewportPadding?: number;
+    className?: string;
+    id?: string;
+    role?: string;
+}
+declare function Overlay({ open, anchorRef, onOpenChange, children, placement, offset, matchAnchorWidth, viewportPadding, className, ...props }: OverlayProps): react.ReactPortal | null;
+
+interface SelectOption {
+    value: string;
+    label: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    keywords?: string[];
+}
+interface SelectProps {
+    id?: string;
+    name?: string;
+    options?: SelectOption[];
+    /** Compatibility path. Prefer the options prop. */
+    children?: ReactNode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string, option?: SelectOption) => void;
+    placeholder?: string;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    fetcher?: (query: string, signal?: AbortSignal) => Promise<SelectOption[]>;
+    debounce?: number;
+    loadingText?: ReactNode;
+    emptyText?: ReactNode;
+    errorText?: ReactNode;
+    clearable?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    placement?: OverlayPlacement;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface AutocompleteProps {
+    id?: string;
+    options: SelectOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string, option?: SelectOption) => void;
+    placeholder?: string;
+    allowCustomValue?: boolean;
+    disabled?: boolean;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+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"> {
+    name: string;
+    size?: "sm" | "md" | "lg";
+    fallback?: string;
+}
+declare function Avatar({ name, size, fallback, className, src, alt, onError, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    label?: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    variant?: "dots" | "ring" | "double-ring";
+    tone?: ComponentTone | "current";
+}
+declare function Spinner({ label: labelProp, size: sizeProp, variant: variantProp, tone: toneProp, className, ...props }: SpinnerProps): react_jsx_runtime.JSX.Element;
+
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: ComponentTone;
+    variant?: "soft" | "solid" | "outline";
+    left?: ReactNode;
+    right?: ReactNode;
+    loading?: boolean;
+    loadingLabel?: string;
+    spinnerProps?: Omit<SpinnerProps, "label">;
+}
+declare function Badge({ tone: toneProp, variant: variantProp, left, right, loading, loadingLabel: loadingLabelProp, spinnerProps, className, children, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+interface BreadcrumbItem {
+    key?: string;
+    label: ReactNode;
+    href?: string;
+    icon?: ReactNode;
+    onClick?: () => void;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    /**
+     * Au-delà, les niveaux intermédiaires passent dans un menu. Le premier et
+     * les deux derniers restent toujours visibles : ce sont les seuls dont on
+     * ait vraiment besoin pour se situer.
+     */
+    maxVisible?: number;
+    separator?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * Le chemin parcouru.
+ *
+ * Le dernier élément n'est jamais un lien : c'est la page courante, et un
+ * lien vers l'endroit où l'on se trouve déjà n'existe pas.
+ */
+declare function Breadcrumb({ items, maxVisible, separator, ariaLabel, className, }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+type TooltipVariant = "solid" | "outline";
+interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, "content"> {
+    content?: ReactNode;
+    children: ReactNode;
+    tone?: ComponentTone;
+    /** Seules `sm`, `md` et `lg` sont dessinées — voir `styles.css`. */
+    size?: ComponentSize;
+    placement?: Placement;
+    variant?: TooltipVariant;
+    /** Délai avant apparition, en millisecondes. */
+    delay?: number;
+    disabled?: boolean;
+}
+/** Alias historique, conservé pour les composants venus du registre. */
+type ITooltipProps = TooltipProps;
+type ITooltipVariant = TooltipVariant;
+/**
+ * Bulle d'aide positionnée hors du flux.
+ *
+ * Le contenu passe par un portail plutôt que par un `position: absolute` dans
+ * le flux : un tooltip posé dans une `Card` ou une cellule de `DataTable` —
+ * toutes deux en `overflow: hidden` — serait sinon rogné.
+ */
+declare function Tooltip({ content, children, placement, variant, tone, size, delay, disabled, className, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: "solid" | "outline" | "ghost";
+    /**
+     * Le ton sémantique de l'action.
+     *
+     * `.sia-button--danger` existait dans la feuille de style sans qu'aucune
+     * prop ne permette de l'atteindre : une action de suppression ne pouvait pas
+     * être rouge sans `className` manuel.
+     */
+    tone?: ComponentTone;
+    size?: "sm" | "md" | "lg";
+    radius?: "default" | "none" | "sm" | "lg" | "full";
+    loading?: boolean;
+    loadingLabel?: string;
+    spinnerProps?: Omit<SpinnerProps, "label">;
+    tooltip?: Omit<TooltipProps, "children">;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface CalendarDay {
+    date: string;
+    day: number;
+    inCurrentMonth: boolean;
+    isToday: boolean;
+    disabled: boolean;
+    selected: boolean;
+    inRange: boolean;
+    rangeEdge?: "start" | "end";
+}
+interface CalendarRangeValue {
+    start: string;
+    end: string;
+}
+type CalendarMode = "month" | "year";
+interface CalendarProps {
+    value?: string;
+    defaultValue?: string;
+    range?: CalendarRangeValue;
+    defaultRange?: CalendarRangeValue;
+    selectionMode?: "single" | "range";
+    month?: string;
+    defaultMonth?: string;
+    mode?: CalendarMode;
+    defaultMode?: CalendarMode;
+    onValueChange?: (value: string) => void;
+    onRangeChange?: (value: CalendarRangeValue) => void;
+    onSelect?: (value: string, source: "date" | "month" | "year") => void;
+    onMonthChange?: (month: string) => void;
+    onPanelChange?: (month: string, mode: CalendarMode) => void;
+    disabledDate?: (date: string) => boolean;
+    validRange?: [string, string];
+    renderDay?: (day: CalendarDay) => ReactNode;
+    cellRender?: (day: CalendarDay, originNode: ReactNode) => ReactNode;
+    headerRender?: (props: {
+        month: string;
+        mode: CalendarMode;
+        onMonthChange: (month: string) => void;
+        onModeChange: (mode: CalendarMode) => void;
+    }) => ReactNode;
+    renderExtraFooter?: () => ReactNode;
+    locale?: string;
+    firstDayOfWeek?: 0 | 1;
+    showWeek?: boolean;
+    fullscreen?: boolean;
+    tone?: ComponentTone;
+    className?: string;
+}
+declare function Calendar({ value, defaultValue, range, defaultRange, selectionMode, month, defaultMonth, mode, defaultMode, onValueChange, onRangeChange, onSelect, onMonthChange, onPanelChange, disabledDate, validRange, renderDay, cellRender, headerRender, renderExtraFooter, locale, firstDayOfWeek, showWeek, fullscreen, tone, className, }: CalendarProps): react_jsx_runtime.JSX.Element;
+
+declare function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardBody({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+interface ChartSeries {
+    key: string;
+    label?: string;
+    values: Array<number | null>;
+    tone?: ComponentTone;
+    /** Couleur explicite. Prioritaire sur `tone`. */
+    color?: string;
+}
+interface ChartProps {
+    series: ChartSeries[];
+    /** Les libellés de l'axe horizontal. Un par point. */
+    labels?: string[];
+    type?: "line" | "area" | "bar";
+    height?: number;
+    /** Bornes de l'axe vertical. Par défaut, déduites des données. */
+    min?: number;
+    max?: number;
+    showGrid?: boolean;
+    showAxis?: boolean;
+    showLegend?: boolean;
+    /** Mise en forme des valeurs — montants, pourcentages. */
+    format?: (value: number) => string;
+    /** Rend le graphique muet : ni survol, ni infobulle. */
+    readOnly?: boolean;
+    caption?: ReactNode;
+    className?: string;
+}
+/**
+ * Un graphique sans dépendance.
+ *
+ * Il couvre les trois formes qui reviennent dans un tableau de bord — courbe,
+ * aire, barres — et rien d'autre. `recharts` reste le bon choix dès qu'il
+ * faut des axes secondaires, du zoom ou des annotations; il pèse alors 90 ko
+ * qu'un projet choisit d'ajouter plutôt que de subir.
+ */
+declare function Chart({ series, labels, type, height, min: minProp, max: maxProp, showGrid, showAxis, showLegend, format, readOnly, caption, className, }: ChartProps): react_jsx_runtime.JSX.Element;
+interface SparklineProps {
+    values: Array<number | null>;
+    tone?: ComponentTone;
+    color?: string;
+    width?: number | string;
+    height?: number;
+    /** Ajoute l'aire sous la courbe. */
+    filled?: boolean;
+    className?: string;
+}
+/**
+ * Une courbe minuscule, sans axes ni survol.
+ *
+ * Elle tient dans une cellule de tableau ou une carte de statistique, là où
+ * un graphique complet ne rentrerait pas.
+ */
+declare function Sparkline({ values, tone, color, width, height, filled, className, }: SparklineProps): react_jsx_runtime.JSX.Element;
+
+type CheckboxValue = string | number;
+interface CheckboxGroupProps {
+    value?: CheckboxValue[];
+    defaultValue?: CheckboxValue[];
+    onValueChange?: (value: CheckboxValue[]) => void;
+    disabled?: boolean;
+    variant?: "default" | "button";
+    orientation?: "horizontal" | "vertical";
+    size?: "sm" | "md" | "lg";
+    tone?: ComponentTone;
+    className?: string;
+    children: ReactNode;
+}
+declare function CheckboxGroup({ value, defaultValue, onValueChange, disabled, variant, orientation, size, tone, className, children, }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "size"> {
+    value?: CheckboxValue;
+    label?: ReactNode;
+    children?: ReactNode;
+    description?: ReactNode;
+    indeterminate?: boolean;
+    onValueChange?: (checked: boolean) => void;
+    size?: "sm" | "md" | "lg";
+    tone?: ComponentTone;
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface ColorPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    onValueChange?: (value: string) => void;
+    showValue?: boolean;
+}
+declare const ColorPicker: react.ForwardRefExoticComponent<ColorPickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    keywords?: string[];
+    icon?: ReactNode;
+    disabled?: boolean;
+    onSelect: () => void;
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    items: CommandItem[];
+    placeholder?: string;
+    emptyLabel?: string;
+    className?: string;
+}
+declare function CommandPalette({ open, onOpenChange, items, placeholder, emptyLabel, className }: CommandPaletteProps): react_jsx_runtime.JSX.Element | null;
+
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    description?: ReactNode;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    tone?: Extract<ComponentTone, "primary" | "danger">;
+    loading?: boolean;
+    onConfirm: () => void | Promise<void>;
+}
+declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel: confirmLabelProp, cancelLabel: cancelLabelProp, tone, loading, onConfirm }: ConfirmDialogProps): react_jsx_runtime.JSX.Element;
+
+declare function Container({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function Stack({ className, ...props }: HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+interface TimerProps {
+    duration?: number;
+    initialValue?: number;
+    direction?: "down" | "up";
+    running?: boolean;
+    interval?: number;
+    onChange?: (milliseconds: number) => void;
+    onFinish?: () => void;
+    format?: (milliseconds: number) => string;
+    className?: string;
+}
+interface TimeParts {
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+declare function parseTimeValue(value?: string): TimeParts;
+declare function formatTimeValue(parts: TimeParts, showSeconds?: boolean): string;
+declare function formatDuration(milliseconds: number, showMilliseconds?: boolean): string;
+declare function Timer({ duration, initialValue, direction, running, interval, onChange, onFinish, format, className }: TimerProps): react_jsx_runtime.JSX.Element;
+
+type CountdownProps = Omit<TimerProps, "direction">;
+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>>;
+
+interface DataTableColumn<T> {
+    key: string;
+    header: ReactNode;
+    cell: (row: T) => ReactNode;
+    align?: "left" | "center" | "right";
+    width?: string;
+    /** Rend l'entête cliquable. Le tri lui-même appartient au serveur. */
+    sortable?: boolean;
+    /** Le champ envoyé au serveur, si différent de `key`. */
+    sortKey?: string;
+}
+interface DataTableProps<T> {
+    columns: Array<DataTableColumn<T>>;
+    data: T[];
+    getRowKey: (row: T) => Key;
+    caption?: string;
+    empty?: ReactNode;
+    loading?: boolean;
+    /** Le tri en vigueur — celui de `useTableQuery`, ou le vôtre. */
+    sort?: TableSort | 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;
+    className?: string;
+}
+/**
+ * Un tableau de données.
+ *
+ * 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.
+ */
+declare function DataTable<T>({ columns, data, getRowKey, caption, empty: emptyProp, loading, sort, onSortChange, stickyHeader, onRowClick, rowClassName, className, }: DataTableProps<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;
+
+interface DatePickerProps extends Pick<CalendarProps, "locale" | "firstDayOfWeek" | "disabledDate" | "cellRender" | "showWeek"> {
+    id?: string;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    min?: string;
+    max?: string;
+    onValueChange?: (value: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    placeholder?: string;
+    formatValue?: (value: string, locale: string) => ReactNode;
+    allowClear?: boolean;
+    showToday?: boolean;
+    renderExtraFooter?: () => ReactNode;
+    placement?: OverlayPlacement;
+    tone?: ComponentTone;
+    invalid?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+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;
+    value?: string;
+    defaultValue?: string;
+    min?: string;
+    max?: string;
+    showSeconds?: boolean;
+    minuteStep?: number;
+    secondStep?: number;
+    hourFormat?: 12 | 24;
+    needConfirm?: boolean;
+    allowClear?: boolean;
+    placeholder?: string;
+    disabledTime?: (value: TimeParts) => boolean;
+    renderExtraFooter?: () => ReactNode;
+    onValueChange?: (value: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    placement?: OverlayPlacement;
+    tone?: ComponentTone;
+    invalid?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+declare const TimePicker: react.ForwardRefExoticComponent<TimePickerProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface DateTimeValue {
+    date: string;
+    time: string;
+}
+interface DateTimePickerProps {
+    value?: DateTimeValue;
+    defaultValue?: DateTimeValue;
+    onValueChange?: (value: DateTimeValue) => void;
+    minuteStep?: number;
+    secondStep?: number;
+    showSeconds?: boolean;
+    hourFormat?: 12 | 24;
+    needConfirm?: boolean;
+    minDate?: string;
+    maxDate?: string;
+    tone?: ComponentTone;
+    invalid?: boolean;
+    disabled?: boolean;
+    dateProps?: Omit<DatePickerProps, "value" | "defaultValue" | "onValueChange" | "tone" | "invalid" | "disabled">;
+    timeProps?: Omit<TimePickerProps, "value" | "defaultValue" | "onValueChange" | "tone" | "invalid" | "disabled">;
+    className?: string;
+}
+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;
+    className?: string;
+}
+declare function Descriptions({ items, title, columns, bordered, className }: DescriptionsProps): react_jsx_runtime.JSX.Element;
+
+interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    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;
+}
+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 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"> {
+    accept?: string;
+    value?: string;
+    onValueChange?: (file: File | null, previewUrl?: string) => void;
+    previewAlt?: string;
+}
+declare function ImageUpload({ accept, value, onValueChange, previewAlt, className, ...props }: ImageUploadProps): react_jsx_runtime.JSX.Element;
+
+type SliderRangeValue = [number, number];
+interface SliderProps {
+    /** Nom du champ, quand le slider est posé dans un formulaire. */
+    name?: string | undefined;
+    /** Mode contrôlé. Laisser vide pour un slider non contrôlé. */
+    value?: SliderValue | undefined;
+    /** Valeur de départ en mode non contrôlé. */
+    defaultValue?: SliderValue | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    step?: number | undefined;
+    range?: boolean | undefined;
+    onChange?: ((value: SliderValue) => void) | undefined;
+    /**
+     * Alias de `onChange`, tel que l'attendaient les composants du registre.
+     * Les deux sont appelés.
+     */
+    onValueChange?: ((value: SliderValue) => void) | undefined;
+    /** Écart minimal entre les deux poignées, en mode plage. */
+    minDistance?: number | undefined;
+    /** Affiche la valeur courante à côté de la piste. */
+    showValue?: boolean | undefined;
+    /** Rendu de la valeur affichée — devise, unité, arrondi. */
+    formatValue?: ((value: number) => string) | undefined;
+    /** Libellé de la poignée basse, annoncé aux lecteurs d'écran. */
+    startLabel?: string | undefined;
+    /** Libellé de la poignée haute, en mode plage. */
+    endLabel?: string | undefined;
+    disabled?: boolean | undefined;
+    className?: string | undefined;
+}
+
+/**
+ * Rendu DOM du slider.
+ *
+ * Tout le calcul — pas, bornes, pourcentages, poignée la plus proche,
+ * non-croisement — vit dans `useSliderState`. Ce fichier ne garde que ce qui
+ * est propre au web : la mesure de la piste, les événements souris et le JSX.
+ */
+declare function Slider({ name, value, defaultValue, min, max, step, range, minDistance, showValue, formatValue, startLabel, endLabel, onChange, onValueChange, disabled, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+interface RatingProps {
+    id?: string;
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    max?: number;
+    /** Autorise les demi-valeurs — 3,5 sur 5. */
+    allowHalf?: boolean;
+    allowClear?: boolean;
+    disabled?: boolean;
+    label?: string;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+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"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (html: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+}
+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"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    preview?: (value: string) => ReactNode;
+}
+declare function MarkdownEditor({ value, defaultValue, onValueChange, preview, className, ...props }: MarkdownEditorProps): react_jsx_runtime.JSX.Element;
+
+interface JsonEditorProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string, parsed: unknown | undefined) => void;
+    formatOnBlur?: boolean;
+}
+declare function JsonEditor({ value, defaultValue, onValueChange, formatOnBlur, className, ...props }: JsonEditorProps): react_jsx_runtime.JSX.Element;
+
+interface OtpInputProps {
+    id?: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    length?: number;
+    inputMode?: "numeric" | "text";
+    mask?: boolean;
+    disabled?: boolean;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+declare function OtpInput({ id, value, defaultValue, onValueChange, length, inputMode, mask, disabled, className, ...ariaProps }: OtpInputProps): react_jsx_runtime.JSX.Element;
+
+interface TagsInputProps {
+    id?: string;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    placeholder?: string;
+    separators?: string[];
+    maxTags?: number;
+    disabled?: boolean;
+    className?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+}
+declare function TagsInput({ id, value, defaultValue, onValueChange, placeholder, separators, maxTags, disabled, className, ...ariaProps }: TagsInputProps): react_jsx_runtime.JSX.Element;
+
+interface ReferenceOption extends SelectOption {
+    description?: ReactNode;
+}
+interface ReferenceSelectProps extends Omit<AutocompleteProps, "options"> {
+    options: ReferenceOption[];
+}
+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";
+type FieldStatus = "default" | "error" | "success" | "warning";
+type FieldControlProps = {
+    id?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+};
+type FieldValue = string | number | SliderRangeValue | boolean | string[] | DateTimeValue | File[] | File | null | undefined;
+type ControlProps = Partial<InputProps & TextareaProps & CurrencyInputProps & DatePickerProps & TimePickerProps & DateTimePickerProps & SelectProps & MultiSelectProps & RadioGroupProps & CheckboxProps & SwitchProps & FileUploadProps & ImageUploadProps & SliderProps & RatingProps & ColorPickerProps & RichTextEditorProps & MarkdownEditorProps & JsonEditorProps & OtpInputProps & TagsInputProps & AutocompleteProps & ReferenceSelectProps>;
+/**
+ * Un branchement de formulaire, quel que soit le type exact de sa valeur.
+ *
+ * `onChange` est écrit en syntaxe de méthode, et ce n'est pas un détail :
+ * TypeScript compare alors ses paramètres de façon bivariante. Sans cela, un
+ * `FieldBinding<string>` — ce que rend `form.bind("email")` — serait refusé
+ * ici, puisque le champ manipule une valeur plus large que la chaîne. Il
+ * faudrait un `as` à chaque branchement.
+ */
+interface FieldBindingLike {
+    name: string;
+    value: FieldValue;
+    onChange(value: unknown): void;
+    onBlur(): void;
+    error?: string | undefined;
+    disabled?: boolean | undefined;
+    required?: boolean | undefined;
+}
+interface FieldProps {
+    /**
+     * Le branchement d'un formulaire, en une prop.
+     *
+     * `<Field label="Courriel" field={form.bind("email")} />` : nom, valeur,
+     * changement, sortie de champ et message d'erreur arrivent ensemble. Le
+     * champ ne sait pas d'où vient l'objet — `useLocalForm`, un adaptateur
+     * react-hook-form, ou trois `useState`. C'est tout l'intérêt du contrat :
+     * aucune bibliothèque de formulaires n'est importée ici.
+     *
+     * Les props écrites explicitement l'emportent, pour corriger un cas isolé
+     * sans démonter le branchement.
+     */
+    field?: FieldBindingLike | undefined;
+    /** Appelé quand le champ est quitté. Déclenche la validation « au blur ». */
+    onBlur?: (() => void) | undefined;
+    type?: FieldType;
+    label?: ReactNode;
+    helpText?: ReactNode;
+    description?: ReactNode;
+    status?: FieldStatus;
+    message?: ReactNode;
+    error?: ReactNode;
+    warning?: ReactNode;
+    success?: ReactNode;
+    required?: boolean;
+    optional?: boolean;
+    optionalLabel?: ReactNode;
+    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>;
+}
+declare function Field(rawProps: FieldProps): react_jsx_runtime.JSX.Element;
+
+interface FiltersBarProps {
+    search?: ReactNode;
+    filters?: ReactNode;
+    actions?: ReactNode;
+    activeCount?: number;
+    onReset?: () => void;
+    resetLabel?: string;
+    className?: string;
+}
+declare function FiltersBar({ search, filters, actions, activeCount, onReset, resetLabel: resetLabelProp, className }: FiltersBarProps): 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;
+
+interface HoverCardProps {
+    content: ReactNode;
+    children: ReactElement<{
+        onMouseEnter?: () => void;
+        onFocus?: () => void;
+    }>;
+    /**
+     * Délai avant ouverture. Il n'est pas cosmétique : sans lui, traverser la
+     * page avec la souris ouvre et ferme une dizaine de panneaux au passage.
+     */
+    openDelay?: number;
+    /** Délai avant fermeture, le temps d'atteindre le panneau à la souris. */
+    closeDelay?: number;
+    placement?: OverlayPlacement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    width?: number | string;
+    className?: string;
+}
+/**
+ * Un aperçu au survol.
+ *
+ * Ce n'est pas un `Tooltip` : celui-ci porte une phrase et se lit d'un coup
+ * d'œil, celui-là porte du contenu — une fiche, un résumé, une image — que
+ * l'on peut vouloir survoler à son tour, voire sélectionner.
+ */
+declare function HoverCard({ content, children, openDelay, closeDelay, placement, open: openProp, onOpenChange, width, className, }: HoverCardProps): react_jsx_runtime.JSX.Element;
+
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    label: string;
+    icon: ReactNode;
+    variant?: "solid" | "outline" | "ghost";
+    size?: "sm" | "md" | "lg";
+    radius?: "default" | "none" | "sm" | "lg" | "full";
+    tooltip?: Omit<TooltipProps, "children">;
+}
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+type IconProps = SVGProps<SVGSVGElement>;
+declare function CalendarIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function ClockIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function ChevronLeftIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function ChevronRightIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function ChevronDownIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function XIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function ArrowRightIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function CheckIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function ChevronUpIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function SearchIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function StarIcon({ fill, ...props }: IconProps): react_jsx_runtime.JSX.Element;
+declare function PlusIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function MinusIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function MoreHorizontalIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function TrashIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function UploadIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function AlertCircleIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function InfoIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function EyeIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function EyeOffIcon(props: IconProps): react_jsx_runtime.JSX.Element;
+
+interface InputNumberProps extends Omit<InputProps, "value" | "defaultValue" | "onChange" | "type" | "right"> {
+    value?: number | null;
+    defaultValue?: number | null;
+    onValueChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Nombre de décimales. Omis, la saisie est laissée telle quelle. */
+    precision?: number;
+    /** Cache les boutons et ne garde que les flèches du clavier. */
+    hideControls?: boolean;
+    /** Unité affichée à droite : kg, %, jours. */
+    suffix?: string;
+}
+/**
+ * Une saisie numérique avec incrément.
+ *
+ * Le champ reste en `type="text"` avec `inputMode="decimal"` : le `number`
+ * natif refuse `maxLength`, accepte `1e5` et `--`, et perd silencieusement sa
+ * valeur quand elle ne lui plaît pas. On garde le clavier numérique sur
+ * mobile, on renonce au reste.
+ */
+declare const InputNumber: react.ForwardRefExoticComponent<InputNumberProps & react.RefAttributes<HTMLInputElement>>;
+
+interface KpiGridProps extends HTMLAttributes<HTMLDivElement> {
+    columns?: 1 | 2 | 3 | 4;
+}
+declare function KpiGrid({ columns, className, ...props }: KpiGridProps): react_jsx_runtime.JSX.Element;
+
+interface LabelProps extends react.LabelHTMLAttributes<HTMLLabelElement> {
+    /** Le ton du libellé. Par défaut, la couleur du texte courant. */
+    tone?: ComponentTone;
+    /** Marque le champ comme obligatoire d'une astérisque. */
+    required?: boolean;
+    /** Atténue le libellé — une mention secondaire, une unité. */
+    muted?: boolean;
+}
+/** Alias historique, attendu par les composants venus du registre. */
+type ILabelProps = LabelProps;
+declare const Label: react.ForwardRefExoticComponent<LabelProps & react.RefAttributes<HTMLLabelElement>>;
+
+declare function MiniCalendar({ className, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+
+interface ModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    closeOnBackdrop?: boolean;
+    closeLabel?: string;
+    className?: string;
+}
+declare function Modal({ open, onOpenChange, title, description, children, footer, closeOnBackdrop, closeLabel: closeLabelProp, className }: ModalProps): react.ReactPortal | null;
+
+interface MonthPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    onValueChange?: (value: string) => void;
+    invalid?: boolean;
+}
+declare const MonthPicker: react.ForwardRefExoticComponent<MonthPickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface PageHeaderProps {
+    title: ReactNode;
+    description?: ReactNode;
+    eyebrow?: ReactNode;
+    actions?: ReactNode;
+    className?: string;
+}
+declare function PageHeader({ title, description, eyebrow, actions, className }: PageHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface PaginationProps {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    previousLabel?: string;
+    nextLabel?: string;
+    /**
+     * Ajoute un champ pour sauter directement à une page.
+     *
+     * Sur quarante pages, atteindre la vingt-septième demande sinon de cliquer
+     * dans les ellipses jusqu'à ce qu'elle apparaisse.
+     */
+    jumpTo?: boolean;
+    /** Affiche « Page 3 sur 40 » à côté des numéros. */
+    showTotal?: boolean;
+    /** Masque les libellés et ne garde que les flèches. */
+    compact?: boolean;
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * La navigation entre les pages.
+ *
+ * Le calcul des numéros et des ellipses vient de `@sia-ui/headless` :
+ * `usePagination` et ce composant appliquent la même règle, écrite une fois.
+ */
+declare function Pagination({ page, totalPages, onPageChange, siblingCount, previousLabel: previousLabelProp, nextLabel: nextLabelProp, jumpTo, showTotal, compact, ariaLabel, className, }: PaginationProps): react_jsx_runtime.JSX.Element | null;
+
+interface PasswordStrength {
+    /** De 0 à 4. */
+    score: number;
+    label: string;
+}
+interface PasswordInputProps extends Omit<InputProps, "type" | "right"> {
+    /** Affiche une jauge sous le champ. */
+    showStrength?: boolean;
+    /** Retire le bouton d'affichage — pour un champ de confirmation. */
+    hideToggle?: boolean;
+    /**
+     * Remplace l'évaluation par défaut. Un projet qui utilise `zxcvbn` branche
+     * son résultat ici; le composant ne dépend de rien.
+     */
+    evaluate?: (value: string) => PasswordStrength;
+}
+/**
+ * Un champ de mot de passe.
+ *
+ * Le bouton d'affichage n'est pas un confort : sur mobile, taper une phrase
+ * de passe à l'aveugle est la première raison pour laquelle les gens en
+ * choisissent une courte.
+ */
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface PermissionGateProps {
+    permissions: string[];
+    require: string | string[];
+    mode?: "all" | "any";
+    fallback?: ReactNode;
+    children: ReactNode;
+}
+declare function PermissionGate({ permissions, require, mode, fallback, children }: PermissionGateProps): react_jsx_runtime.JSX.Element;
+
+interface PhoneCountry {
+    /** Code ISO 3166-1 alpha-2. */
+    code: string;
+    /** Indicatif, avec le `+`. */
+    dial: string;
+    label: string;
+    flag: string;
+    /** Nombre de chiffres attendus après l'indicatif. */
+    digits?: number;
+    /** Découpage visuel du numéro national : `[1, 2, 2, 2, 2]` → `6 12 34 56 78`. */
+    groups?: number[];
+}
+/**
+ * Les pays servis par défaut.
+ *
+ * Volontairement court et centré sur la zone franc : une liste mondiale pèse
+ * 40 ko pour être fausse six mois plus tard. La prop `countries` la remplace
+ * entièrement quand un projet en a besoin d'une autre.
+ */
+declare const DEFAULT_COUNTRIES: PhoneCountry[];
+interface PhoneInputProps extends Omit<InputProps, "value" | "defaultValue" | "onChange" | "type" | "left"> {
+    /** Le numéro complet, indicatif compris : `+237612345678`. */
+    value?: string;
+    defaultValue?: string;
+    /** Reçoit toujours la forme E.164, sans espaces. */
+    onValueChange?: (value: string) => void;
+    countries?: PhoneCountry[];
+    /** Pays présélectionné, par code ISO. */
+    defaultCountry?: string;
+    /** Verrouille le pays et masque le sélecteur. */
+    lockCountry?: boolean;
+}
+/**
+ * Un numéro de téléphone international.
+ *
+ * L'indicatif et le numéro national sont deux champs distincts, parce qu'une
+ * seule zone de saisie oblige à taper le `+237` à chaque fois — ce que
+ * personne ne fait, d'où des numéros enregistrés sans indicatif.
+ *
+ * Aucune validation réelle n'est tentée : `libphonenumber-js` fait cela bien,
+ * pèse 145 ko, et se branche par-dessus si un projet en a besoin. Ici, le
+ * découpage visuel et la forme E.164 en sortie.
+ */
+declare const PhoneInput: react.ForwardRefExoticComponent<PhoneInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface PopoverProps {
+    content: ReactNode;
+    title?: ReactNode;
+    children: ReactElement<{
+        onClick?: () => void;
+        "aria-expanded"?: boolean;
+    }>;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: OverlayPlacement;
+    trigger?: "click" | "hover";
+    variant?: "solid" | "outline";
+    tone?: ComponentTone;
+    disabled?: boolean;
+    className?: string;
+}
+declare function Popover({ content, title, children, open: openProp, defaultOpen, onOpenChange, placement, trigger, variant, tone, disabled, className }: PopoverProps): react_jsx_runtime.JSX.Element;
+
+interface ProgressProps {
+    /** La valeur courante. Omise, la barre passe en indéterminé. */
+    value?: number | undefined;
+    max?: number;
+    shape?: "bar" | "circle";
+    tone?: ComponentTone;
+    size?: ComponentSize;
+    /** Épaisseur du trait, en pixels. Par défaut selon la taille. */
+    thickness?: number | undefined;
+    /** Affiche le pourcentage — au centre du cercle, en bout de barre. */
+    showValue?: boolean;
+    /** Remplace l'affichage par défaut. */
+    format?: ((percent: number, value: number, max: number) => ReactNode) | undefined;
+    label?: ReactNode;
+    className?: string;
+}
+/**
+ * L'avancement d'une tâche.
+ *
+ * Sans `value`, le composant passe en indéterminé plutôt que d'afficher zéro :
+ * « je travaille » et « je n'ai rien fait » ne se ressemblent pas.
+ */
+declare function Progress(props: ProgressProps): react_jsx_runtime.JSX.Element;
+
+interface QRCodeProps {
+    value: string;
+    size?: number;
+    label?: string;
+    render?: (value: string, size: number) => ReactNode;
+    className?: string;
+}
+declare function QRCode({ value, size, label, render, className }: QRCodeProps): react_jsx_runtime.JSX.Element;
+
+interface RelativeTimeProps extends Omit<HTMLAttributes<HTMLTimeElement>, "dateTime"> {
+    value: Date | string | number;
+    locale?: string;
+    prefix?: string;
+    refreshInterval?: number;
+}
+declare function RelativeTime({ value, locale, prefix, refreshInterval, className, title, ...props }: RelativeTimeProps): react_jsx_runtime.JSX.Element | null;
+
+interface RequireSessionProps<TUser, TTenant, TRule> {
+    session: SessionStore<TUser, TTenant, TRule>;
+    children: ReactNode;
+    /** La règle de droits exigée, s'il y en a une. */
+    require?: TRule;
+    /**
+     * Affiché pendant la vérification.
+     *
+     * Ce rendu est ce qui distingue cette garde d'un `if (!user) redirect` :
+     * tant que le serveur n'a pas répondu, on attend. Rediriger pendant la
+     * vérification renvoie à la page de connexion quelqu'un qui est connecté.
+     */
+    pending?: ReactNode;
+    /** Rendu quand il n'y a pas de session. */
+    fallback?: ReactNode;
+    /** Rendu quand la session existe mais que les droits manquent. */
+    forbidden?: ReactNode;
+    /** Laisse passer une session `incomplete` — profil pas encore rempli. */
+    allowIncomplete?: boolean;
+    /**
+     * Appelé une fois quand la vérification conclut à l'absence de session.
+     *
+     * C'est ici que l'application navigue : `navigate("/login")`,
+     * `router.push(…)`, ou rien du tout si `fallback` suffit. La garde ne
+     * connaît aucun routeur.
+     */
+    onUnauthenticated?: (state: SessionState<TUser, TTenant>) => void;
+    onForbidden?: (state: SessionState<TUser, TTenant>) => void;
+    onIncomplete?: (state: SessionState<TUser, TTenant>) => void;
+    className?: string;
+}
+/**
+ * Ce qui se trouve derrière une session valide.
+ *
+ * Écrite cinq fois dans les projets du disque D, cinq fois de la même façon
+ * à la cible de redirection près. Elle ne dépend d'aucun routeur : elle rend
+ * un état et prévient, l'application décide où aller.
+ *
+ * > Ceci protège l'interface, pas les données. Une route masquée reste une
+ * > route ouverte tant que le serveur ne refuse pas l'appel.
+ */
+declare function RequireSession<TUser, TTenant, TRule = PermissionRule>({ session, children, require: rule, pending, fallback, forbidden, allowIncomplete, onUnauthenticated, onForbidden, onIncomplete, className, }: RequireSessionProps<TUser, TTenant, TRule>): react_jsx_runtime.JSX.Element;
+interface CanProps<TUser, TTenant, TRule> {
+    session: SessionStore<TUser, TTenant, TRule>;
+    require: TRule;
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+/**
+ * Un morceau d'interface derrière un droit.
+ *
+ * `PermissionGate` fait la même chose à partir d'un tableau de permissions
+ * passé à la main; celui-ci lit la session et suit son évaluateur — jokers,
+ * expression textuelle ou égalité stricte selon le serveur.
+ */
+declare function Can<TUser, TTenant, TRule = PermissionRule>({ session, require: rule, children, fallback, }: CanProps<TUser, TTenant, TRule>): react_jsx_runtime.JSX.Element;
+
+interface ResizablePanelProps {
+    first: ReactNode;
+    second: ReactNode;
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    direction?: "horizontal" | "vertical";
+    className?: string;
+}
+declare function ResizablePanel({ first, second, defaultSize, minSize, maxSize, direction, className }: ResizablePanelProps): react_jsx_runtime.JSX.Element;
+
+interface ScrollAreaProps {
+    children: ReactNode;
+    /** Hauteur maximale. Au-delà, la zone défile. */
+    maxHeight?: number | string;
+    height?: number | string;
+    orientation?: "vertical" | "horizontal" | "both";
+    /**
+     * Estompe le contenu aux bords tant qu'il reste quelque chose à faire
+     * défiler. C'est le seul indice fiable quand la barre est fine ou masquée.
+     */
+    fade?: boolean;
+    className?: string;
+}
+/**
+ * Une zone défilante sobre.
+ *
+ * La barre reste celle du navigateur, seulement affinée : une barre
+ * réimplémentée en JavaScript coûte un écouteur de défilement, deux mesures
+ * par image et perd le défilement inertiel des pavés tactiles. Le seul ajout
+ * est l'estompe des bords, qui ne demande qu'un booléen par côté.
+ */
+declare function ScrollArea({ children, maxHeight, height, orientation, fade, className, }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
+
+interface SearchInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Appelé à la validation, et après le délai si `searchDelay` est posé. */
+    onSearch?: (value: string) => void;
+    /**
+     * Millisecondes d'inactivité avant de déclencher `onSearch`.
+     *
+     * `0` — le défaut — ne déclenche qu'à la validation. Au-delà, la recherche
+     * part quand la frappe s'arrête : c'est ce que chaque projet réécrivait
+     * autour de ce champ.
+     */
+    searchDelay?: number;
+    clearable?: boolean;
+    searchLabel?: string;
+    clearLabel?: string;
+}
+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.
+ *
+ * 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.
+ */
+declare function Sidebar({ items, activeKey, collapsed, header, footer, onNavigate, ariaLabel, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    width?: CSSProperties["width"];
+    height?: CSSProperties["height"];
+    radius?: CSSProperties["borderRadius"];
+    circle?: boolean;
+}
+declare function Skeleton({ className, width, height, radius, circle, style, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface StatisticProps {
+    value: number;
+    label?: ReactNode;
+    format?: "number" | "currency" | "percent";
+    locale?: string;
+    currency?: string;
+    precision?: number;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    trend?: number;
+    className?: string;
+}
+declare function Statistic({ value, label, format, locale, currency, precision, prefix, suffix, trend, className }: StatisticProps): react_jsx_runtime.JSX.Element;
+
+interface StatCardProps extends StatisticProps {
+    icon?: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+}
+declare function StatCard({ icon, description, action, className, ...statisticProps }: StatCardProps): react_jsx_runtime.JSX.Element;
+
+type StepStatus = "done" | "current" | "upcoming" | "error";
+interface StepItem {
+    key: string;
+    title: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    /** Forcé au besoin; sinon déduit de `current`. */
+    status?: StepStatus;
+    disabled?: boolean;
+}
+interface StepsProps {
+    items: StepItem[];
+    /** Index de l'étape en cours. Ce qui précède est fait, ce qui suit à venir. */
+    current?: number;
+    orientation?: "horizontal" | "vertical";
+    size?: "sm" | "md";
+    /** Rend les étapes cliquables — pour revenir en arrière dans un tunnel. */
+    onStepClick?: (item: StepItem, index: number) => void;
+    className?: string;
+}
+/**
+ * Une progression en étapes.
+ *
+ * Le trait entre deux étapes se remplit plutôt que de changer de couleur d'un
+ * coup : c'est ce qui donne le sens de la marche, vers l'avant.
+ */
+declare function Steps({ items, current, orientation, size, onStepClick, className, }: StepsProps): react_jsx_runtime.JSX.Element;
+
+interface TabsProps {
+    value?: string;
+    defaultValue: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+    children: ReactNode;
+}
+declare function Tabs({ value, defaultValue, onValueChange, className, children }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsList({ className, children }: {
+    className?: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ value, disabled, children }: {
+    value: string;
+    disabled?: boolean;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ value, className, children }: {
+    value: string;
+    className?: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface TimeRangeValue {
+    start: string;
+    end: string;
+}
+interface TimeRangePickerProps extends Pick<TimePickerProps, "minuteStep" | "secondStep" | "showSeconds" | "hourFormat" | "needConfirm" | "allowClear"> {
+    value?: TimeRangeValue;
+    defaultValue?: TimeRangeValue;
+    onValueChange?: (value: TimeRangeValue) => void;
+    order?: boolean;
+    startLabel?: string;
+    endLabel?: string;
+    tone?: ComponentTone;
+    invalid?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+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 {
+    key: string;
+    title: ReactNode;
+    description?: ReactNode;
+    time?: ReactNode;
+    tone?: ComponentTone;
+}
+interface TimelineProps {
+    items: TimelineItem[];
+    pending?: ReactNode;
+    className?: string;
+}
+declare function Timeline({ items, pending, className }: TimelineProps): react_jsx_runtime.JSX.Element;
+
+interface ToasterProps {
+    /** Coin par défaut des annonces qui n'en précisent pas. */
+    placement?: ToastPlacement;
+    /** Nombre visible simultanément. Au-delà, la plus ancienne s'efface. */
+    limit?: number;
+    /** Durée par défaut, pour les tons qui n'en imposent pas une. */
+    duration?: number;
+    /** Largeur d'une annonce. */
+    width?: number | string;
+    /** Décalage depuis le bord de l'écran. */
+    offset?: number | string;
+    /**
+     * Où rendre la pile. Par défaut, un nœud créé sous `document.body`.
+     *
+     * À fournir quand le thème est porté par un conteneur plutôt que par la
+     * racine du document : sorties de ce conteneur, les annonces perdraient
+     * ses variables et s'afficheraient dans le thème clair.
+     */
+    container?: HTMLElement | null | undefined;
+    className?: string;
+}
+/**
+ * La pile visible.
+ *
+ * Un seul `<Toaster />` à la racine de l'application. Il rend les six coins :
+ * une annonce peut choisir le sien, ce qui permet à une confirmation
+ * d'apparaître près du geste qui l'a déclenchée et à une panne générale de
+ * s'imposer en haut de l'écran.
+ */
+declare function Toaster({ placement, limit, duration, width, offset, container, className, }: ToasterProps): react.ReactPortal | null;
+interface ToastProviderProps extends PropsWithChildren, ToasterProps {
+}
+/**
+ * Enveloppe les enfants et monte le `Toaster`.
+ *
+ * Aucun contexte : le magasin vit hors de React. Ce composant n'existe que
+ * pour monter la pile au bon endroit sans y penser.
+ */
+declare function ToastProvider({ children, ...props }: ToastProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * L'API des annonces, pour ceux qui préfèrent un hook.
+ *
+ * Elle rend exactement l'objet `toast`, dont l'identité ne change jamais :
+ * l'appeler dans un `useCallback` ou un `useEffect` ne relance rien.
+ */
+declare function useToast(): ((input: _sia_ui_headless.ToastInput) => string) & {
+    success: (input: _sia_ui_headless.ToastInput) => string;
+    info: (input: _sia_ui_headless.ToastInput) => string;
+    warning: (input: _sia_ui_headless.ToastInput) => string;
+    error: (input: _sia_ui_headless.ToastInput) => string;
+    loading: (input: _sia_ui_headless.ToastInput) => string;
+    promise<T>(promise: Promise<T>, messages: _sia_ui_headless.PromiseMessages<T>): Promise<T>;
+    update: (id: ToastId, patch: ToastOptions) => void;
+    dismiss: (id?: ToastId) => void;
+    custom: (options: ToastOptions) => string;
+};
+
+interface ToggleProps {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    children?: ReactNode;
+    icon?: ReactNode;
+    /** Obligatoire quand le contenu se réduit à une icône. */
+    ariaLabel?: string;
+    size?: ComponentSize;
+    tone?: ComponentTone;
+    variant?: "solid" | "outline" | "ghost";
+    disabled?: boolean;
+    className?: string;
+}
+/**
+ * Un bouton à deux états.
+ *
+ * Ce n'est pas un `Switch` : un interrupteur décrit un réglage qui persiste,
+ * une bascule décrit un état de l'interface ici et maintenant — gras, filtre
+ * actif, colonne affichée. `aria-pressed` porte cette différence.
+ */
+declare function Toggle({ pressed: pressedProp, defaultPressed, onPressedChange, children, icon, ariaLabel, size, tone, variant, disabled, className, }: ToggleProps): react_jsx_runtime.JSX.Element;
+interface ToggleGroupOption {
+    value: string;
+    label?: ReactNode;
+    icon?: ReactNode;
+    ariaLabel?: string;
+    disabled?: boolean;
+}
+interface ToggleGroupProps {
+    options: ToggleGroupOption[];
+    /** `single` : une valeur ou aucune. `multiple` : un tableau. */
+    type?: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    /** Une chaîne en `single`, un tableau en `multiple` — comme `value`. */
+    onValueChange?: (value: string | string[]) => void;
+    size?: ComponentSize;
+    tone?: ComponentTone;
+    /** Autorise à tout désélectionner en `single`. */
+    deselectable?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * Plusieurs bascules qui partagent une valeur.
+ *
+ * Le repère glisse d'une option à l'autre au lieu de sauter : c'est la même
+ * idée que les onglets, et c'est ce qui rend le changement lisible.
+ */
+declare function ToggleGroup({ options, type, value: valueProp, defaultValue, onValueChange, size, tone, deselectable, disabled, ariaLabel, className, }: ToggleGroupProps): react_jsx_runtime.JSX.Element;
+
+interface TourStep {
+    target: string;
+    title: ReactNode;
+    description?: ReactNode;
+}
+interface TourProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    steps: TourStep[];
+    initialStep?: number;
+    onStepChange?: (step: number) => void;
+    className?: string;
+}
+declare function Tour({ open, onOpenChange, steps, initialStep, onStepChange, className }: TourProps): react.ReactPortal | null;
+
+interface TransferItem {
+    key: Key;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface TransferProps {
+    items: TransferItem[];
+    targetKeys: Key[];
+    onChange: (targetKeys: Key[]) => void;
+    sourceTitle?: string;
+    targetTitle?: string;
+    className?: string;
+}
+declare function Transfer({ items, targetKeys, onChange, sourceTitle, targetTitle, className }: TransferProps): react_jsx_runtime.JSX.Element;
+
+interface TreeNode {
+    key: Key;
+    label: ReactNode;
+    children?: TreeNode[];
+    disabled?: boolean;
+}
+interface TreeProps {
+    nodes: TreeNode[];
+    defaultExpandedKeys?: Key[];
+    selectedKey?: Key | undefined;
+    onSelect?: ((node: TreeNode) => void) | undefined;
+    className?: string;
+}
+declare function Tree({ nodes, defaultExpandedKeys, selectedKey, onSelect, className }: TreeProps): react_jsx_runtime.JSX.Element;
+
+interface TreeSelectProps {
+    nodes: TreeNode[];
+    value?: Key | undefined;
+    onValueChange?: (value: Key, node: TreeNode) => void;
+    placeholder?: string;
+    className?: string;
+}
+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";
+}
+declare function Heading({ level, size, className, ...props }: HeadingProps): react_jsx_runtime.JSX.Element;
+interface TextProps extends HTMLAttributes<HTMLParagraphElement> {
+    tone?: ComponentTone;
+    size?: "sm" | "md" | "lg";
+}
+declare function Text({ tone, size, className, ...props }: TextProps): react_jsx_runtime.JSX.Element;
+declare function InlineCode({ className, ...props }: HTMLAttributes<HTMLElement>): react_jsx_runtime.JSX.Element;
+
+interface UnsavedChangesGuardProps {
+    when: boolean;
+    message?: string;
+}
+declare function UnsavedChangesGuard({ when, message }: UnsavedChangesGuardProps): null;
+declare function confirmUnsavedNavigation(when: boolean, message?: string): boolean;
+
+interface WeekPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    onValueChange?: (value: string) => void;
+    invalid?: boolean;
+}
+declare const WeekPicker: react.ForwardRefExoticComponent<WeekPickerProps & react.RefAttributes<HTMLInputElement>>;
+
+interface YearPickerProps {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    onValueChange?: (year: number) => void;
+    className?: string;
+}
+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 };