@rovula/ui 0.1.27 → 0.1.29

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import * as React from 'react';
+import * as React$1 from 'react';
 import React__default, { ReactElement, ReactNode, FC, ComponentPropsWithoutRef, CSSProperties, HTMLAttributes, FormHTMLAttributes, ComponentType } from 'react';
 import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
 import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
@@ -7,7 +7,9 @@ import { VariantProps } from 'class-variance-authority';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { DayPicker, Modifiers } from 'react-day-picker';
 import * as PopoverPrimitive from '@radix-ui/react-popover';
-import { ColumnDef, SortingState } from '@tanstack/react-table';
+import { RowData, Row, ColumnDef, SortingState, PaginationState, RowSelectionState, Cell, ExpandedState, Header } from '@tanstack/react-table';
+export { Cell, ColumnDef, ExpandedState, Header, PaginationState, Row, RowData, RowSelectionState, SortingState, Table as TanstackTable } from '@tanstack/react-table';
+import { Options as Options$2 } from '@/components/Dropdown/Dropdown';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
 import * as SliderPrimitive from '@radix-ui/react-slider';
@@ -416,6 +418,17 @@ type DropdownProps = {
         selectedOption: Options$1 | null | undefined;
         onClick: (option: Options$1) => void;
     }) => ReactNode;
+    /**
+     * When `true`, keep focus on the input after selecting an option so the
+     * menu stays open (useful for inline row-editing where the user may Tab
+     * to the next field instead of closing the dropdown).
+     */
+    keepOpenAfterSelect?: boolean;
+    /**
+     * Render the options list via a React portal so it escapes containers
+     * with `overflow: hidden/auto` (e.g. DataTable scroll wrappers).
+     */
+    portal?: boolean;
 } & Omit<InputProps, "value" | "onSelect">;
 declare const Dropdown: React__default.ForwardRefExoticComponent<{
     id?: string;
@@ -446,16 +459,27 @@ declare const Dropdown: React__default.ForwardRefExoticComponent<{
         selectedOption: Options$1 | null | undefined;
         onClick: (option: Options$1) => void;
     }) => ReactNode;
+    /**
+     * When `true`, keep focus on the input after selecting an option so the
+     * menu stays open (useful for inline row-editing where the user may Tab
+     * to the next field instead of closing the dropdown).
+     */
+    keepOpenAfterSelect?: boolean;
+    /**
+     * Render the options list via a React portal so it escapes containers
+     * with `overflow: hidden/auto` (e.g. DataTable scroll wrappers).
+     */
+    portal?: boolean;
 } & Omit<InputProps, "onSelect" | "value"> & React__default.RefAttributes<HTMLInputElement>>;
 
-declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ({
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
     disabled?: boolean | null | undefined;
     error?: boolean | null | undefined;
     isFloatable?: boolean | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;
 
 declare const Input: React__default.ForwardRefExoticComponent<{
     size?: "sm" | "md" | "lg";
@@ -522,15 +546,15 @@ declare const ActionButton: React__default.ForwardRefExoticComponent<{
 type BaseAvatarProps = {
     imageUrl?: string;
     text?: string;
-    fallback?: React.ReactNode;
-    icon?: React.ReactNode;
-    children?: React.ReactNode;
+    fallback?: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+    children?: React$1.ReactNode;
     size?: "xxs" | "xs" | "sm" | "md" | "lg";
     rounded?: "full" | "normal" | "none";
     className?: string;
     imageClassName?: string;
     fallbackClassName?: string;
-    style?: React.CSSProperties;
+    style?: React$1.CSSProperties;
 };
 type AvatarTextProps = {
     text: string;
@@ -538,15 +562,15 @@ type AvatarTextProps = {
 } & BaseAvatarProps;
 type AvatarImageProps = {
     imageUrl: string;
-    fallback: React.ReactNode;
+    fallback: React$1.ReactNode;
     type: "image";
 } & BaseAvatarProps;
 type AvatarIconProps = {
-    icon: string;
+    icon: React$1.ReactNode;
     type: "icon";
 } & BaseAvatarProps;
 type AvatarProps = AvatarTextProps | AvatarImageProps | AvatarIconProps;
-declare const Avatar: React.FC<AvatarProps>;
+declare const Avatar: React$1.FC<AvatarProps>;
 
 type AvatarGroupProps = {
     maxDisplay?: number;
@@ -572,8 +596,8 @@ type BadgeProps = {
     /** Optional percentage value shown below the label */
     percent?: number;
     className?: string;
-} & React.HTMLAttributes<HTMLSpanElement>;
-declare const Badge: React.ForwardRefExoticComponent<{
+} & React$1.HTMLAttributes<HTMLSpanElement>;
+declare const Badge: React$1.ForwardRefExoticComponent<{
     /** Badge text label */
     label: string;
     /** Color variant */
@@ -586,16 +610,16 @@ declare const Badge: React.ForwardRefExoticComponent<{
     /** Optional percentage value shown below the label */
     percent?: number;
     className?: string;
-} & React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+} & React$1.HTMLAttributes<HTMLSpanElement> & React$1.RefAttributes<HTMLSpanElement>>;
 type SeverityLevel = "highest" | "high" | "medium" | "low" | "lowest";
 type SeverityBadgeProps = {
     severity: SeverityLevel;
     className?: string;
-} & React.HTMLAttributes<HTMLSpanElement>;
-declare const SeverityBadge: React.ForwardRefExoticComponent<{
+} & React$1.HTMLAttributes<HTMLSpanElement>;
+declare const SeverityBadge: React$1.ForwardRefExoticComponent<{
     severity: SeverityLevel;
     className?: string;
-} & React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+} & React$1.HTMLAttributes<HTMLSpanElement> & React$1.RefAttributes<HTMLSpanElement>>;
 
 declare const CollapsibleButton: React__default.ForwardRefExoticComponent<{
     children: React__default.ReactNode;
@@ -619,15 +643,15 @@ interface CollapsibleProps {
 }
 declare const Collapsible: CollapsibleComponent;
 
-type CalendarProps = React.ComponentProps<typeof DayPicker>;
+type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
 declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
 declare namespace Calendar {
     var displayName: string;
 }
 
-declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
-declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
 type DatePickerProps = {
     date: Date | undefined;
@@ -713,70 +737,417 @@ type IconProps = {
 } & React__default.SVGProps<SVGSVGElement>;
 declare const Icon: React__default.FC<IconProps>;
 
-declare const Table: React.ForwardRefExoticComponent<{
+declare const Table: React$1.ForwardRefExoticComponent<{
     rootClassName?: string;
-    rootRef?: React.LegacyRef<HTMLDivElement>;
-} & React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
-declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
-declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
-declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
-declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
-declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
-declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
-declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+    rootRef?: React$1.LegacyRef<HTMLDivElement>;
+    /**
+     * Wraps the table in a rounded frame (`rounded-md` + `border-table-c-border`).
+     * Uses an outer `overflow-hidden` shell and an inner scroll area so corners clip
+     * cleanly (same pattern as scrollable bordered tables elsewhere in the system).
+     * For pagination in the same frame, wrap `Table` + `TablePagination` in your own
+     * bordered div instead of relying on this prop alone.
+     */
+    bordered?: boolean;
+    /**
+     * When false, render only `<table>` (no inner `overflow-auto` wrapper).
+     * Use when a parent already provides the scrollport — e.g. `DataTable` — so
+     * `sticky` header rows stick to the correct ancestor.
+     * Ignored when `bordered` is true (bordered tables always use the inner scroll shell).
+     */
+    scrollableWrapper?: boolean;
+} & React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React$1.ForwardRefExoticComponent<{
+    striped?: boolean;
+} & React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React$1.ForwardRefExoticComponent<{
+    divided?: boolean;
+    colDivided?: boolean;
+} & React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+interface TablePaginationProps {
+    pageIndex: number;
+    pageSize: number;
+    totalCount: number;
+    pageSizeOptions?: number[];
+    onPageChange: (pageIndex: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+    className?: string;
+}
+declare const TablePagination: React$1.ForwardRefExoticComponent<TablePaginationProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type EditDisplayMode = "cell" | "row";
+type EditTrigger = "click" | "doubleClick";
+type EditableColumnDef<TData extends RowData = RowData, TValue = unknown> = ColumnDef<TData, TValue> & {
+    /**
+     * Enable inline editing for this column.
+     * - `true` — always editable
+     * - `(row) => boolean` — conditionally editable (e.g. dependent fields)
+     */
+    enableEditing?: boolean | ((row: Row<TData>) => boolean);
+    /**
+     * Which built-in editor to render.
+     * - `"text"` — `TextInput` (default when `enableEditing` is truthy)
+     * - `"select"` — `Dropdown`
+     * - `"number"` — `NumberInput`
+     * - `"checkbox"` — `Checkbox`
+     * - `"custom"` — user-provided renderer via `editCustomCell`
+     */
+    editVariant?: "text" | "select" | "number" | "checkbox" | "custom";
+    /** Props forwarded to the `TextInput` editor (variant `"text"`). */
+    editTextProps?: {
+        placeholder?: string;
+    };
+    /** Props forwarded to the `Dropdown` editor (variant `"select"`). */
+    editSelectProps?: {
+        options: Options$2[] | ((row: Row<TData>) => Options$2[]);
+        placeholder?: string;
+    };
+    /** Props forwarded to the `NumberInput` editor (variant `"number"`). */
+    editNumberProps?: {
+        placeholder?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+        precision?: number;
+        allowDecimal?: boolean;
+        allowNegative?: boolean;
+    };
+    /** Props forwarded to the `Checkbox` editor (variant `"checkbox"`). */
+    editCheckboxProps?: {
+        label?: string;
+    };
+    /**
+     * Render function for a fully custom edit cell (variant `"custom"`).
+     *
+     * Receives the current row and a `commit` callback. Call `commit(rawValue)`
+     * to persist the change — the engine will run `onCommit` / `buildPatch`
+     * as usual.
+     *
+     * ```tsx
+     * editCustomCell: (row, { commit, errorMessage }) => (
+     *   <MyColorPicker
+     *     value={row.original.color}
+     *     onChange={(c) => commit(c)}
+     *     error={errorMessage}
+     *   />
+     * )
+     * ```
+     */
+    editCustomCell?: (row: Row<TData>, ctx: {
+        /** Persist the edited value — runs `onCommit` / `buildPatch` as usual. */
+        commit: (rawValue: string) => void;
+        /** Exit edit mode without committing (same as pressing Escape). */
+        blur: () => void;
+        columnId: string;
+        autoFocus: boolean;
+        errorMessage?: string;
+        onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => void;
+    }) => React.ReactNode;
+    /**
+     * Return an error message for the current cell value to display inline
+     * validation feedback. Return `undefined` or empty string when valid.
+     */
+    editError?: (row: Row<TData>) => string | undefined;
+    /**
+     * Build a custom `Partial<TData>` patch from the raw committed value.
+     * When omitted the engine defaults to `{ [columnId]: rawValue }`.
+     *
+     * Use this for dependent-field resets, value transforms, etc.
+     *
+     * ```ts
+     * onCommit: (_row, value) => ({
+     *   dataCategory: value,
+     *   dataType: "", format: "", source: "",
+     * })
+     * ```
+     */
+    onCommit?: (row: Row<TData>, value: string) => Partial<TData>;
+    /**
+     * When `true`, a cell whose `enableEditing` returns `false` renders a
+     * **disabled** TextInput / Dropdown (matching `editVariant`) instead of
+     * falling back to `displayCell` or plain text.
+     */
+    editShowDisabledField?: boolean;
+    /**
+     * Custom preview renderer shown when the cell is **not** in edit mode.
+     * Defaults to the plain string value of `row.original[key]`.
+     */
+    displayCell?: (row: Row<TData>) => React.ReactNode;
+};
+interface DataTableEditingProps<TData extends RowData = RowData> {
+    /** Master switch — set `true` to enable editing features. */
+    enableEditing?: boolean;
+    /** How editing is activated visually. @default "cell" */
+    editDisplayMode?: EditDisplayMode;
+    /** Gesture that enters edit mode. @default "click" */
+    editTrigger?: EditTrigger;
+    /**
+     * Called every time a cell commits a new value.  The `patch` object is
+     * built from the column's `commitResets` / `mapCommitValue` or defaults
+     * to `{ [columnId]: rawValue }`.
+     */
+    onCellCommit?: (rowId: string, columnId: string, patch: Partial<TData>) => void;
+    /**
+     * Rows that return `true` render their editable columns in edit mode
+     * **permanently** (e.g. an "add" footer row).
+     */
+    alwaysEditing?: (row: Row<TData>) => boolean;
+    /**
+     * When `true` (the default when `enableEditing` is set), Tab / Shift+Tab
+     * inside an editing cell moves focus to the next / previous editable
+     * column in the same row.
+     */
+    enableCellTabTraversal?: boolean;
+    /**
+     * Explicit ordered list of column ids for Tab traversal.  When omitted
+     * the engine auto-detects editable columns in definition order.
+     */
+    editableColumnIds?: string[];
+}
 
-interface DataTableProps<TData, TValue> {
-    columns: ColumnDef<TData, TValue>[];
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        exactWidth?: number | string;
+        align?: "left" | "center" | "right";
+        cellClassName?: string;
+        headerCellClassName?: string;
+        colSpan?: number | ((row: Row<TData>) => number);
+    }
+}
+
+type DataTablePaginationMode = "server" | "client" | "infinite";
+interface DataTableProps<TData, TValue> extends DataTableEditingProps<TData> {
+    columns: (ColumnDef<TData, TValue> | EditableColumnDef<TData, TValue>)[];
     data: TData[];
     manualSorting?: boolean;
     onSorting?: (sorting: SortingState) => void;
+    /**
+     * "client"   – DataTable manages page state internally with TanStack
+     * "server"   – caller controls page state; pass pageIndex/pageSize/totalCount
+     * "infinite" – no pagination bar; fetchMoreData enables infinite scroll
+     */
+    paginationMode?: DataTablePaginationMode;
+    /** Required for "server" mode */
+    totalCount?: number;
+    pageIndex?: number;
+    pageSize?: number;
+    onPaginationChange?: (state: PaginationState) => void;
+    pageSizeOptions?: number[];
+    /** Called when user scrolls near bottom (infinite mode). */
     fetchMoreData?: () => void;
+    /**
+     * Threshold in pixels from the bottom of the scroll container at which
+     * `fetchMoreData` is triggered. Defaults to 10px.
+     */
+    fetchMoreOffset?: number;
+    /**
+     * When `paginationMode` is `"infinite"`, shows a built-in footer row (spinner +
+     * label) and suppresses additional `fetchMoreData` calls until this is false again.
+     */
+    fetchingMore?: boolean;
+    /** Accessible label next to the spinner (default: "Loading more…"). */
+    fetchingMoreLabel?: string;
+    /**
+     * When there are no rows yet, shows a built-in loading state instead of the
+     * empty placeholder. Also suppresses `fetchMoreData` while true (infinite mode).
+     */
+    loading?: boolean;
+    /** Label for the initial-loading state (default: "Loading…"). */
+    loadingLabel?: string;
+    /**
+     * When true, DataTable will only render a vertical window of rows based on
+     * the scroll position of its internal scroll container. This is a basic
+     * fixed-row-height virtualizer intended for large but finite lists.
+     *
+     * Notes / limitations:
+     * - Only vertical row virtualization is supported.
+     * - Assumes approximately fixed row height; pass `virtualRowEstimate` to tune.
+     * - Works with selection, row actions, and basic infinite scroll, but more
+     *   complex combinations (tree rows, reorder, etc.) may have visual quirks.
+     */
+    virtualized?: boolean;
+    /**
+     * Estimated height in pixels for a single table row when `virtualized` is
+     * true. Used to compute how many rows fit in the viewport and the spacer
+     * heights above/below the rendered window.
+     * @default 40
+     */
+    virtualRowEstimate?: number;
+    /**
+     * Optional row id(s) to highlight visually. Highlighting is purely cosmetic
+     * and does not affect selection state.
+     */
+    highlightRowId?: string | string[];
+    /**
+     * When true and `highlightRowId` is set, moving the mouse pointer out of the
+     * scroll area will automatically scroll the first highlighted row back into
+     * view (centered).
+     */
+    scrollToHighlightOnMouseLeave?: boolean;
+    selectable?: boolean;
+    onRowSelectionChange?: (rows: RowSelectionState) => void;
+    /** Render actions into the last fixed-width column. Receives the TanStack Row. */
+    rowActions?: (row: Row<TData>) => React__default.ReactNode;
+    /**
+     * Enable drag-to-reorder rows. A grip handle column is prepended automatically.
+     * Requires each data item to have a unique `id` field (string | number)
+     * or supply `getRowId` to derive one.
+     */
+    reorderable?: boolean;
+    /** Return a unique string id for each row. Defaults to `(row) => row.id`. */
+    getRowId?: (row: TData) => string;
+    /** Called after the user drops a row into a new position. Receives the reordered data array. */
+    onRowReorder?: (data: TData[]) => void;
+    /**
+     * When `reorderable`, rows that return `true` are not draggable and are
+     * omitted from the sortable context (e.g. a pinned footer "add" row).
+     * Those rows are also kept **after** all sortable rows whenever column sort
+     * is applied (order among locked rows follows original `data` order).
+     */
+    isRowReorderLocked?: (row: Row<TData>) => boolean;
+    /** Fired when a body row is clicked. */
+    onRowClick?: (row: Row<TData>, event: React__default.MouseEvent) => void;
+    /** Fired when an individual body cell is clicked. */
+    onCellClick?: (cell: Cell<TData, unknown>, row: Row<TData>, event: React__default.MouseEvent) => void;
+    /** Return child rows to enable tree expansion */
+    getSubRows?: (row: TData) => TData[] | undefined;
+    /** Initial expanded state — `true` = all expanded, `{}` = all collapsed (uncontrolled) */
+    defaultExpanded?: ExpandedState | boolean;
+    /** Controlled expanded state — omit to let DataTable manage internally */
+    expanded?: ExpandedState;
+    onExpandedChange?: (expanded: ExpandedState) => void;
+    /**
+     * Rounded frame + `border-table-c-border` around the scroll area and pagination
+     * (same token as primitive `Table` `bordered`). Set `false` when embedding in
+     * another bordered surface.
+     */
+    bordered?: boolean;
+    /**
+     * `"panel"` sets `data-surface="panel"` for table token overrides (modal /
+     * drawer). `"default"` leaves surface to ancestors.
+     */
+    surface?: "default" | "panel";
+    /** Alternate row background colours (RowA / RowB) */
+    striped?: boolean;
+    /** Add vertical column dividers */
+    divided?: boolean;
+    /** Return a className string to apply to a specific body row. */
+    rowClassName?: (row: Row<TData>, index: number) => string | undefined;
+    /** Return a className string to apply to a specific body cell. */
+    cellClassName?: (cell: Cell<TData, unknown>, row: Row<TData>) => string | undefined;
+    /** Return a className string to apply to a specific column header cell (`<th>`). */
+    headerCellClassName?: (header: Header<TData, unknown>) => string | undefined;
+    /** Additional className for the header section (`<thead>`). */
+    headerClassName?: string;
+    /** Additional className for the header row (`<tr>` inside `<thead>`). */
+    headerRowClassName?: string;
+    /**
+     * Controls when the sort indicator button is visible on sortable columns.
+     * - `"hover"` – shown only when hovering the column header (default)
+     * - `"always"` – always visible
+     */
+    sortIndicatorVisibility?: "always" | "hover";
+    /**
+     * CSS `table-layout` mode.
+     * - `"auto"` – browser sizes columns based on content (default)
+     * - `"fixed"` – non-`exactWidth` columns use their `size` as pixel widths;
+     *   the **last** visible non-exact column absorbs leftover width so the table
+     *   stays full-width. `meta.exactWidth` (px) columns stay locked.
+     * - `"equal"` – all visible columns without `meta.exactWidth` share the
+     *   remaining table width equally via
+     *   `calc((100% - <sum of exactWidth>px) / <flex column count>)`.
+     *   Columns with `meta.exactWidth` are still locked to their exact value.
+     *   With `resizable`, drag-to-resize is disabled for `equal` so widths stay
+     *   equal; `fixed`/`auto` keep column resize handles.
+     */
+    tableLayout?: "auto" | "fixed" | "equal";
+    /**
+     * Show a column menu (⋮) on each hideable column header: first a dropdown
+     * (“Hide … column”, “Manage columns”), then the full manage panel from the
+     * second action. Pass `true` or `ColumnManagementOptions` to tune features.
+     */
+    columnManagement?: boolean | ColumnManagementOptions;
+    /** Allow user to drag-resize column widths */
+    resizable?: boolean;
+    /**
+     * Global minimum column width in pixels when `resizable` is true.
+     * Individual columns can override with `minSize` in their column def.
+     * @default 60
+     */
+    columnMinSize?: number;
+    /**
+     * Global maximum column width in pixels when `resizable` is true.
+     * Individual columns can override with `maxSize` in their column def.
+     * @default Number.MAX_SAFE_INTEGER (no limit)
+     */
+    columnMaxSize?: number;
+    className?: string;
+    /**
+     * Sets `data-testid` on the root container and derives sub-ids for the
+     * table (`{testId}-table`), header (`{testId}-thead`), body (`{testId}-tbody`),
+     * rows (`{testId}-row-{rowId}`), and cells (`{testId}-cell-{rowId}-{colId}`).
+     */
+    testId?: string;
+}
+interface ColumnManagementOptions {
+    /** Show drag-handle to reorder columns. @default true */
+    reorder?: boolean;
+    /** Show per-column visibility Switch. @default true */
+    visibility?: boolean;
+    /** Show "Hide all" button. @default true */
+    hideAll?: boolean;
+    /** Show "Show all" button. @default true */
+    showAll?: boolean;
 }
-declare function DataTable<TData, TValue>({ data, columns, manualSorting, onSorting, fetchMoreData, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+declare function DataTable<TData, TValue>({ data, columns, manualSorting, onSorting, paginationMode, totalCount, pageIndex: controlledPageIndex, pageSize: controlledPageSize, onPaginationChange, pageSizeOptions, fetchMoreData, fetchMoreOffset, fetchingMore, fetchingMoreLabel, loading, loadingLabel, highlightRowId, scrollToHighlightOnMouseLeave, selectable, onRowSelectionChange, rowActions, reorderable, getRowId: getRowIdProp, onRowReorder, isRowReorderLocked, onRowClick, onCellClick, getSubRows, defaultExpanded, expanded: controlledExpanded, onExpandedChange, bordered, surface, striped, divided, rowClassName, cellClassName, headerCellClassName, headerClassName, headerRowClassName, sortIndicatorVisibility, tableLayout, columnManagement: columnManagementProp, resizable, columnMinSize, columnMaxSize, virtualized, virtualRowEstimate, className, enableEditing, editDisplayMode, editTrigger, onCellCommit, alwaysEditing, enableCellTabTraversal, editableColumnIds: editableColumnIdsProp, testId, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
 
-declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
-declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
-declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     showCloseButton?: boolean;
     closeButtonClassName?: string;
-} & React.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLDivElement>>;
 declare const DialogHeader: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 declare const DialogBody: {
-    ({ className, scrollable, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    ({ className, scrollable, ...props }: React$1.HTMLAttributes<HTMLDivElement> & {
         scrollable?: boolean;
     }): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 declare const DialogFooter: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
-declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
 
-declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
-declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
-declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialog: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const AlertDialogHeader: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 declare const AlertDialogFooter: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
-declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
-declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogTitle: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 
 type SearchProps = {
     id?: string;
@@ -885,55 +1256,55 @@ declare const InputFilter: React__default.ForwardRefExoticComponent<{
     }) => ReactNode;
 } & Omit<InputProps, "onSelect" | "value"> & React__default.RefAttributes<HTMLInputElement>>;
 
-interface CustomSliderProps extends React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
+interface CustomSliderProps extends React$1.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
     trackClassName?: string;
     rangeClassName?: string;
     thumbClassName?: string;
-    trackStyle?: React.CSSProperties;
-    thumbStyle?: React.CSSProperties;
-    rangeStyle?: React.CSSProperties;
+    trackStyle?: React$1.CSSProperties;
+    thumbStyle?: React$1.CSSProperties;
+    rangeStyle?: React$1.CSSProperties;
 }
-declare const Slider: React.ForwardRefExoticComponent<CustomSliderProps & React.RefAttributes<HTMLSpanElement>>;
-type SliderProps = React.ComponentProps<typeof Slider>;
+declare const Slider: React$1.ForwardRefExoticComponent<CustomSliderProps & React$1.RefAttributes<HTMLSpanElement>>;
+type SliderProps = React$1.ComponentProps<typeof Slider>;
 
-declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
     forceHover?: boolean;
-} & React.RefAttributes<HTMLButtonElement>>;
+} & React$1.RefAttributes<HTMLButtonElement>>;
 
-declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
-declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
-declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
-declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     inset?: boolean;
     selected?: boolean;
-    icon?: React.ReactNode;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
-    icon?: React.ReactNode;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    icon?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    icon?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const DropdownMenuShortcut: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 
-declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
-declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
-declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const TooltipArrow: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
-declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipArrow: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React$1.RefAttributes<SVGSVGElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
 interface TooltipProps {
     children: ReactNode;
@@ -947,20 +1318,20 @@ interface TooltipProps {
 }
 declare function TooltipSimple({ children, content, open, defaultOpen, onOpenChange, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
 
-declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
-declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & VariantProps<(props?: ({
+declare const ToastProvider: React$1.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React$1.RefAttributes<HTMLOListElement>, "ref"> & VariantProps<(props?: ({
     position?: "top-center" | "top-left" | "top-right" | "bottom-center" | "bottom-left" | "bottom-right" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLOListElement>>;
-declare const Toast$1: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLOListElement>>;
+declare const Toast$1: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React$1.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
     variant?: "default" | "success" | "info" | "warning" | "error" | null | undefined;
     showBorder?: boolean | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
-declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-type ToastProps = React.ComponentPropsWithoutRef<typeof Toast$1>;
-type ToastActionElement = React.ReactElement<typeof ToastAction>;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type ToastProps = React$1.ComponentPropsWithoutRef<typeof Toast$1>;
+type ToastActionElement = React$1.ReactElement<typeof ToastAction>;
 
 type ToasterProps = {
     viewportClassName?: string;
@@ -974,13 +1345,13 @@ declare function Toaster({ viewportClassName, titleClassName, descriptionClassNa
 
 type ToasterToast = ToastProps & {
     id: string;
-    title?: React.ReactNode;
-    description?: React.ReactNode;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
     action?: ToastActionElement;
     contentMode?: "vertical" | "horizontal";
     onClose?: () => void;
     iconProps?: IconProps;
-    renderIcon?: () => React.ReactElement;
+    renderIcon?: () => React$1.ReactElement;
 };
 type ToasterPosition = "top-center" | "top-left" | "top-right" | "bottom-center" | "bottom-left" | "bottom-right" | undefined;
 declare const actionTypes: {
@@ -1142,12 +1513,12 @@ type FocusedScrollViewProps = {
 declare const FocusedScrollView: React__default.FC<FocusedScrollViewProps>;
 
 type ScrollbarSize = "m" | "s" | "xs";
-interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
+interface ScrollAreaProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /**
      * Scrollbar thickness.
-     * - `m`  — 12 px  (shows track border)
-     * - `s`  — 6 px   (default, shows no track border)
-     * - `xs` — 2 px   (shows no track border)
+     * - `m`  — 12 px  (default, shows track border + 2px thumb inset)
+     * - `s`  — 6 px   (shows track border + 2px thumb inset)
+     * - `xs` — 2 px   (no track border, no thumb inset)
      */
     scrollbarSize?: ScrollbarSize;
     /**
@@ -1177,10 +1548,10 @@ interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
  * <ScrollArea className="max-h-[160px]">...section B items...</ScrollArea>
  * ```
  */
-declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollArea: React$1.ForwardRefExoticComponent<ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
 
 type FormChildren<TFieldValues extends FieldValues> = ReactNode | ((methods: UseFormReturn<TFieldValues>) => ReactNode);
 type FormController<TFieldValues extends FieldValues> = {
@@ -1301,14 +1672,14 @@ type ConfirmDialogProps = {
     onOpenChange?: (open: boolean) => void;
     title: string;
     description?: string;
-    children?: React.ReactNode;
+    children?: React$1.ReactNode;
     confirmLabel?: string;
     cancelLabel?: string;
     onConfirm?: () => void;
     onCancel?: () => void;
     /** Fires whenever the dialog closes, regardless of how (cancel button, overlay, Escape). */
     onClose?: () => void;
-    trigger?: React.ReactNode;
+    trigger?: React$1.ReactNode;
     /**
      * When provided, the user must type this exact text before the confirm button is enabled.
      * e.g. typeToConfirm="confirm" or typeToConfirm="delete"
@@ -1324,13 +1695,13 @@ type ConfirmDialogProps = {
     cancelClassName?: string;
     confirmClassName?: string;
 };
-declare const ConfirmDialog: React.FC<ConfirmDialogProps>;
+declare const ConfirmDialog: React$1.FC<ConfirmDialogProps>;
 
 type FormDialogAction = {
     label: string;
     onClick?: () => void;
-    variant?: React.ComponentProps<typeof Button$1>["variant"];
-    color?: React.ComponentProps<typeof Button$1>["color"];
+    variant?: React$1.ComponentProps<typeof Button$1>["variant"];
+    color?: React$1.ComponentProps<typeof Button$1>["color"];
     disabled?: boolean;
     isLoading?: boolean;
     type?: "button" | "submit" | "reset";
@@ -1341,8 +1712,8 @@ type FormDialogProps = {
     onOpenChange?: (open: boolean) => void;
     title: string;
     description?: string;
-    children?: React.ReactNode;
-    trigger?: React.ReactNode;
+    children?: React$1.ReactNode;
+    trigger?: React$1.ReactNode;
     /**
      * Primary action (right side of footer).
      */
@@ -1364,7 +1735,7 @@ type FormDialogProps = {
     formId?: string;
     testId?: string;
 };
-declare const FormDialog: React.FC<FormDialogProps>;
+declare const FormDialog: React$1.FC<FormDialogProps>;
 
 type MenuOption = {
     value: string;
@@ -1877,4 +2248,4 @@ declare const srgbToHex: (color: string) => string;
  */
 declare function getLucideIconNames(): Promise<string[]>;
 
-export { ActionButton, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeColor, type BadgeProps, Button, type ButtonProps, Calendar, Checkbox, Collapsible, ConfirmDialog, type ConfirmDialogProps, type ControlledFormFactoryOptions, type CustomSliderProps, DataTable, type DataTableProps, DatePicker, Dialog, DialogBody, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Dropdown, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type DropdownProps, Field, FieldMessage, type FieldMessageProps, type FieldProps, FocusedScrollView, Footer, type FooterProps, type FooterVariant, Form, type FormController, FormDialog, type FormDialogAction, type FormDialogProps, type FormProps, Icon, Input, InputFilter, type InputFilterProps, type InputProps, Label, Loading, type MaskRule, MaskedTextInput, type MaskedTextInputProps, Menu, DropdownMenuItem as MenuItem, type MenuItemType, DropdownMenuLabel as MenuLabel, type MenuOption, type MenuProps, DropdownMenuSeparator as MenuSeparator, Navbar, type NavbarProps, type NavbarVariant, NumberInput, type NumberInputProps, type OptionLike, type Options$1 as Options, OtpInput, OtpInputGroup, type OtpInputGroupProps, type OtpInputProps, PasswordInput, type PasswordInputProps, Popover, PopoverContent, PopoverTrigger, ProgressBar, RadioGroup, RadioGroupItem, ScrollArea, type ScrollAreaProps, type ScrollbarSize, Search, type SearchProps, SeverityBadge, type SeverityBadgeProps, type SeverityLevel, Slider, type SliderProps, Switch, THEME_COLOR_KEYS, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, Text, TextArea, type TextAreaProps, TextInput, type ThemeColorKey, Toast$1 as Toast, ToastAction, type ToastActionElement, ToastClose, ToastDescription, type ToastProps, ToastProvider, ToastTitle, ToastViewport, Toaster, Tooltip, TooltipArrow, TooltipContent, TooltipProvider, TooltipSimple, TooltipTrigger, Tree, type TreeData, TreeItem, type TreeItemProps, type TreeProps, type UseControlledFormOptions, type UseOptionBridgeOptions, ValidationHintList, type ValidationHintListProps, type ValidationHintMode, type ValidationHintRule, type ValidationHintState, cn, createControlledForm, createYupResolver, getEndDateOfDay, getLucideIconNames, getStartDateOfDay, getStartEndTimestampOfDay, getThemeColor, getThemeColors, getTimestampUTC, reducer, resloveTimestamp, srgbToHex, toast, useControlledForm, useOptionBridge, usePrevious, useToast };
+export { ActionButton, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, Badge, type BadgeColor, type BadgeProps, Button, type ButtonProps, Calendar, Checkbox, Collapsible, type ColumnManagementOptions, ConfirmDialog, type ConfirmDialogProps, type ControlledFormFactoryOptions, type CustomSliderProps, DataTable, type DataTableEditingProps, type DataTablePaginationMode, type DataTableProps, DatePicker, Dialog, DialogBody, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Dropdown, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, type DropdownProps, type EditDisplayMode, type EditTrigger, type EditableColumnDef, Field, FieldMessage, type FieldMessageProps, type FieldProps, FocusedScrollView, Footer, type FooterProps, type FooterVariant, Form, type FormController, FormDialog, type FormDialogAction, type FormDialogProps, type FormProps, Icon, Input, InputFilter, type InputFilterProps, type InputProps, Label, Loading, type MaskRule, MaskedTextInput, type MaskedTextInputProps, Menu, DropdownMenuItem as MenuItem, type MenuItemType, DropdownMenuLabel as MenuLabel, type MenuOption, type MenuProps, DropdownMenuSeparator as MenuSeparator, Navbar, type NavbarProps, type NavbarVariant, NumberInput, type NumberInputProps, type OptionLike, type Options$1 as Options, OtpInput, OtpInputGroup, type OtpInputGroupProps, type OtpInputProps, PasswordInput, type PasswordInputProps, Popover, PopoverContent, PopoverTrigger, ProgressBar, RadioGroup, RadioGroupItem, ScrollArea, type ScrollAreaProps, type ScrollbarSize, Search, type SearchProps, SeverityBadge, type SeverityBadgeProps, type SeverityLevel, Slider, type SliderProps, Switch, THEME_COLOR_KEYS, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TablePagination, type TablePaginationProps, TableRow, Tabs, Text, TextArea, type TextAreaProps, TextInput, type ThemeColorKey, Toast$1 as Toast, ToastAction, type ToastActionElement, ToastClose, ToastDescription, type ToastProps, ToastProvider, ToastTitle, ToastViewport, Toaster, Tooltip, TooltipArrow, TooltipContent, TooltipProvider, TooltipSimple, TooltipTrigger, Tree, type TreeData, TreeItem, type TreeItemProps, type TreeProps, type UseControlledFormOptions, type UseOptionBridgeOptions, ValidationHintList, type ValidationHintListProps, type ValidationHintMode, type ValidationHintRule, type ValidationHintState, cn, createControlledForm, createYupResolver, getEndDateOfDay, getLucideIconNames, getStartDateOfDay, getStartEndTimestampOfDay, getThemeColor, getThemeColors, getTimestampUTC, reducer, resloveTimestamp, srgbToHex, toast, useControlledForm, useOptionBridge, usePrevious, useToast };