@assure-one/design-system 1.47.1 → 1.48.0

package/dist/{data-table-view-D9a1_IRF.d.ts → data-table-view-CNTfzEyS.d.ts}

@@ -1,10 +1,11 @@
 import * as React$1 from 'react';
-import { ReactNode, CSSProperties } from 'react';
+import { ReactNode, CSSProperties, RefObject } from 'react';
 import { V as Variant, I as Intent, C as ControlSize, S as Shape } from './vocab-DornLJbW.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as SelectPrimitive from '@radix-ui/react-select';
-import { S as SelectMessages, T as TableMessages } from './types-BTHIs2nk.js';
+import { S as SelectMessages, T as TableMessages } from './types-CKpkEBvW.js';
 import { a as BrandTheme } from './brand-theme-ZYM867Jz.js';
+import { O as Option } from './option-izy_4w4Z.js';
 
 /**
  * `Code` parts, stamped as `data-slot="code[-<part>]"` (ADR-008). Inline, the
@@ -277,7 +278,7 @@ type ToastSlot = "region" | "root" | "icon" | "title" | "description" | "action"
  *
  * @experimental Slot names are experimental until ADR-008 is accepted (W2-18).
  */
-type TableSlot = "root" | "wrapper" | "header" | "body" | "footer" | "row" | "head" | "cell" | "caption" | "sort" | "sort-indicator" | "group-row" | "group-row-toggle" | "group-row-label" | "group-row-trailing";
+type TableSlot = "root" | "wrapper" | "header" | "body" | "footer" | "row" | "head" | "cell" | "caption" | "sort" | "sort-indicator" | "group-row" | "group-row-toggle" | "group-row-label" | "group-row-trailing" | "sort-rank" | "resize-handle" | "head-menu" | "cell-secondary" | "spacer-row" | "group-row-count" | "group-row-subtotal";
 /**
  * `DataTable*` parts, stamped as `data-slot="data-table[-<part>]"` (ADR-008).
  * These are `C-DT-PARTS`, the parallel copy of `Table*` that W6-03 folds back
@@ -303,7 +304,7 @@ type TableSlot = "root" | "wrapper" | "header" | "body" | "footer" | "row" | "he
  *
  * @experimental Slot names are experimental until ADR-008 is accepted (W2-18).
  */
-type DataTableSlot = "root" | "toolbar" | "spacer" | "results-count" | "header" | "body" | "row" | "head" | "head-button" | "head-indicator" | "cell" | "checkbox-cell" | "search" | "filters" | "columns-menu" | "content" | "bulk-actions" | "pagination";
+type DataTableSlot = "root" | "toolbar" | "spacer" | "results-count" | "header" | "body" | "row" | "head" | "head-button" | "head-indicator" | "cell" | "checkbox-cell" | "search" | "filters" | "columns-menu" | "content" | "bulk-actions" | "pagination" | "head-menu" | "cell-secondary" | "load-more";
 /**
  * `Pagination` parts, stamped as `data-slot="pagination[-<part>]"` (ADR-008).
  * `root` is the `<nav>`. The current page carries `data-selected` alongside
@@ -328,10 +329,11 @@ type ShellSlot = "root" | "main" | "content";
  * `[&>div:first-child]` overrides because there is no name for
  * `section-header`, `link-label` or `user` today.
  *
- * `group/sidebar`, `data-labels`, `data-state`, `data-peek`, `data-overlay`,
- * `data-collapsible` and `data-variant` on the root are **unchanged** — they
- * are the frozen part of `C-DOM-06`, and no state attribute is re-stamped over
- * them. W7-03 adds `data-collapsed` to the slots and the `SidebarSection`
+ * `group/sidebar`, `data-labels`, `data-state`, `data-collapsible` and
+ * `data-variant` on the root are **unchanged** — they are the frozen part of
+ * `C-DOM-06`, and no state attribute is re-stamped over them. (`data-peek` and
+ * `data-overlay` were only ever present mid-hover-peek; with peek removed they
+ * are never set.) W7-03 adds `data-collapsed` to the slots and the `SidebarSection`
  * header slot; this change only names the parts.
  *
  * `group` is a `SidebarLinkGroup`: `group-link` is its activating row,
@@ -351,7 +353,7 @@ type SidebarSlot = "root" | "trigger" | "pin" | "brand" | "brand-text" | "sectio
  *
  * @experimental Slot names are experimental until ADR-008 is accepted (W2-18).
  */
-type SidebarBrandSwitcherSlot = "root" | "trigger" | "icon";
+type SidebarBrandSwitcherSlot = "root" | "trigger" | "icon" | "mark";
 /**
  * `Text` parts, stamped as `data-slot="text"` (ADR-008). One part: the
  * element that carries the role, and the element `className` lands on (with
@@ -478,6 +480,37 @@ type FieldsetSlot = "root" | "legend";
  * @experimental Slot names are experimental until ADR-008 is accepted (W4-10).
  */
 type ComboboxSlot = "root" | "control" | "value" | "chips" | "input" | "icon" | "clear" | "toggle" | "content" | "header" | "list" | "group" | "group-heading" | "item" | "item-indicator" | "create" | "empty" | "loading" | "footer";
+/**
+ * `StatStrip` parts, stamped as `data-slot="stat-strip[-<part>]"` (ADR-008).
+ * `root` is the joined card (`role="group"`, `data-state="expanded" |
+ * "collapsed"`, `data-loading`), `content` the grid / inline row the toggle
+ * controls, `toggle` the wrapper of the collapse chevron. Each
+ * `StatStripItem` is an `item` (`data-pressed` and `data-disabled` when it is
+ * a filter toggle, `data-intent`, `data-glow` while it highlights a change)
+ * with its `label`, `value` and `caption`.
+ *
+ * @experimental Slot names are experimental until ADR-008 is accepted (W2-18).
+ */
+type StatStripSlot = "root" | "content" | "toggle" | "item" | "label" | "value" | "caption";
+/**
+ * `FilterChips` parts, stamped as `data-slot="filter-chips[-<part>]"` (ADR-008):
+ * the row (`root`), one `chip` per active facet, the collapsed `overflow`
+ * ("+N") chip and its popover `overflow-panel` listing each `overflow-facet`
+ * and `overflow-value`, and the trailing `clear` ("Clear all") action.
+ *
+ * @experimental
+ */
+type FilterChipsSlot = "root" | "chip" | "overflow" | "overflow-panel" | "overflow-facet" | "overflow-value" | "clear";
+/**
+ * `ListPage` parts, stamped as `data-slot="list-page[-<part>]"` (ADR-008): the
+ * full-height, non-scrolling `root`; the `stats`, `toolbar` and `bulk-bar`
+ * bands; the toolbar's `search`, `chips`, `count` and `actions` cells; the
+ * `table` card, its single `scroll` region and pinned `footer`; and the
+ * live `result-count`.
+ *
+ * @experimental
+ */
+type ListPageSlot = "root" | "stats" | "toolbar" | "search" | "chips" | "count" | "actions" | "table" | "scroll" | "footer" | "bulk-bar" | "result-count";
 
 /** The emphasis subset a badge offers. @experimental */
 type BadgeVariant = Extract<Variant, "solid" | "soft" | "outline">;
@@ -902,7 +935,23 @@ interface TableProps extends React.TableHTMLAttributes<HTMLTableElement> {
      * @experimental
      */
     messages?: Partial<TableMessages>;
+    /**
+     * Pin the identity column (PR 3): the first cell of every row sticks to the
+     * start edge while the wrapper scrolls horizontally. One attribute on the
+     * wrapper (`data-sticky-first`), read by a descendant selector — no prop on
+     * each cell. A cell's own `sticky` still works and wins.
+     *
+     * @experimental
+     */
+    stickyFirstColumn?: boolean | undefined;
 }
+/**
+ * Whether the wrapper scrolls — its columns overflow it, or its rows do when
+ * it has a height (`stickyHeader`). Measured with a ResizeObserver (SSR renders
+ * "not overflowing"); the wrapper only becomes a focusable, labelled region
+ * when there is actually something to scroll — a table that fits gets no tab
+ * stop, and its DOM stays what it was (C-DOM-09).
+ */
 declare const Table: React$1.ForwardRefExoticComponent<TableProps & React$1.RefAttributes<HTMLTableElement>>;
 type TableHeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
 declare const TableHeader: React$1.ForwardRefExoticComponent<TableHeaderProps & React$1.RefAttributes<HTMLTableSectionElement>>;
@@ -964,8 +1013,58 @@ interface TableHeadProps extends Omit<React.ThHTMLAttributes<HTMLTableCellElemen
      * @experimental
      */
     sort?: TableSortDirection | null | undefined;
-    /** Receives the next step of the sort cycle when the header is activated. */
-    onSortChange?: ((sort: TableSortDirection | null) => void) | undefined;
+    /**
+     * Receives the next step of the sort cycle when the header is activated.
+     * The second argument (PR 3) says whether the activation was *additive* —
+     * Shift-click or Shift+Enter — so a multi-sort table adds a secondary key
+     * instead of replacing the primary. Single-argument handlers are unaffected.
+     */
+    onSortChange?: ((sort: TableSortDirection | null, meta: TableSortChangeMeta) => void) | undefined;
+    /**
+     * The column's 1-based rank in a multi-key sort (PR 3). Rendered as a small
+     * number beside the indicator when the table sorts by more than one key, and
+     * spoken as "priority N". Omit for single-sort tables.
+     *
+     * @experimental
+     */
+    sortIndex?: number | undefined;
+    /**
+     * The direction an unsorted column starts in (PR 3): `desc` for dates and
+     * money, where the newest / largest is the useful first answer. Default `asc`.
+     *
+     * @experimental
+     */
+    sortFirstDirection?: TableSortDirection | undefined;
+    /**
+     * A trailing slot inside the header cell, after the label — the
+     * `TableHeadMenu` trigger (PR 3). A separate element from the sort button,
+     * so opening the menu never sorts.
+     *
+     * @experimental
+     */
+    menu?: React.ReactNode;
+    /**
+     * Renders a resize handle on the trailing edge (PR 3): pointer drag, or
+     * ArrowLeft / ArrowRight (Shift for bigger steps) while it has focus. The
+     * handle is its own element — dragging it never sorts. Pair with `width`
+     * and `onWidthChange`.
+     *
+     * @experimental
+     */
+    resizable?: boolean | undefined;
+    /** Receives the new width in px while resizing. */
+    onWidthChange?: ((width: number) => void) | undefined;
+    /** Double-click or Enter on the resize handle: fit the column to its content. */
+    onAutoSize?: (() => void) | undefined;
+    /** Resize floor in px. Default `48`. */
+    minWidth?: number | undefined;
+    /** Resize ceiling in px. Default `800`. */
+    maxWidth?: number | undefined;
+}
+/** What `TableHead`'s `onSortChange` learns besides the next direction. @experimental */
+interface TableSortChangeMeta {
+    /** Shift was held: add or update a secondary sort key instead of replacing the sort. */
+    additive: boolean;
 }
 declare const TableHead: React$1.ForwardRefExoticComponent<TableHeadProps & React$1.RefAttributes<HTMLTableCellElement>>;
 interface TableCellProps extends Omit<React.TdHTMLAttributes<HTMLTableCellElement>, "align">, TableCellCommonProps {
@@ -986,6 +1085,18 @@ interface TableCellProps extends Omit<React.TdHTMLAttributes<HTMLTableCellElemen
     overflowTooltip?: boolean;
 }
 declare const TableCell: React$1.ForwardRefExoticComponent<TableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+type TableCellSecondaryProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * TableCellSecondary — a quiet second line inside a cell (an email under a
+ * name, an engagement under a client) that renders only in the comfortable
+ * ("Detailed") density. Under a `data-ds-density="compact"` ancestor — the
+ * `Table density` prop, or any density scope — it is hidden by a selector, so
+ * switching density changes the *content* of a row, not just its padding,
+ * with no prop on each cell.
+ *
+ * @experimental
+ */
+declare const TableCellSecondary: React$1.ForwardRefExoticComponent<TableCellSecondaryProps & React$1.RefAttributes<HTMLSpanElement>>;
 interface TableGroupRowProps extends Omit<React.HTMLAttributes<HTMLTableRowElement>, "children"> {
     /** How many columns the row's one cell spans — the table's column count. */
     colSpan: number;
@@ -1004,7 +1115,36 @@ interface TableGroupRowProps extends Omit<React.HTMLAttributes<HTMLTableRowEleme
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
     /** Copy for the collapse toggle; prop > provider > English default (W5-20). */
-    messages?: Partial<Pick<TableMessages, "collapseSection" | "expandSection">>;
+    messages?: Partial<Pick<TableMessages, "collapseSection" | "expandSection" | "groupLoadedOf">>;
+    /**
+     * Rows in the group (PR 3): shown after the label as "12". With
+     * `totalCount` above it (infinite mode, only some rows loaded) it reads
+     * "12 of 30 loaded". @experimental
+     */
+    count?: number | undefined;
+    /** Rows the group holds in all, when more exist than are loaded. @experimental */
+    totalCount?: number | undefined;
+    /** Locale for the count. @experimental */
+    locale?: string | undefined;
+    /**
+     * Subtotal cells (PR 3), one entry per column (`colSpan` entries). The label
+     * cell spans every column up to the first non-empty entry; each later entry
+     * renders as its own cell, so a subtotal sits under its column. Mark money /
+     * count entries `numeric` to right-align them like the column's cells.
+     * @experimental
+     */
+    subtotals?: readonly (TableGroupRowSubtotal | null | undefined)[] | undefined;
+    /**
+     * Stick under the sticky header while its rows scroll past (PR 3). Default:
+     * follows the table's `stickyHeader`, as before. @experimental
+     */
+    sticky?: boolean | undefined;
+}
+/** One subtotal cell of a {@link TableGroupRow}. @experimental */
+interface TableGroupRowSubtotal {
+    value: React.ReactNode;
+    /** Right-align with tabular figures, matching a `numeric` column. */
+    numeric?: boolean | undefined;
 }
 /**
  * TableGroupRow — a full-width section header row inside `TableBody` (W6-01
@@ -1021,6 +1161,446 @@ declare const TableGroupRow: React$1.ForwardRefExoticComponent<TableGroupRowProp
 type TableCaptionProps = React.HTMLAttributes<HTMLTableCaptionElement>;
 declare const TableCaption: React$1.ForwardRefExoticComponent<TableCaptionProps & React$1.RefAttributes<HTMLTableCaptionElement>>;
 
+/**
+ * `useDataTable<TRow>()` (W6-04/W6-05; target architecture §35.2) — the
+ * headless controller behind every data table.
+ *
+ * No DOM, no styling: the hook owns the six state slices a table needs —
+ * **sorting · pagination · search · selection · columnVisibility · filters** —
+ * each independently controllable (`value` + `onValueChange`) or uncontrolled
+ * with a default, plus the whole-state pair `state` / `onStateChange` for a
+ * product hook that mirrors the table into the URL. It derives the rows to
+ * render (filtered → searched → sorted → paged) from typed column definitions
+ * and hands back stable ids for the ARIA wiring the rendering layer adds.
+ *
+ * Why it exists: today `DataTableView` keeps sort, search and page in private
+ * state, so TAX seeds it once through `initialSort` and *listens to header
+ * clicks by header text* to keep the URL in step (`use-queue-view.ts`), and
+ * PRO hand-rolls the same three states per table. Every slice here is
+ * observable and settable, so those bridges become `sorting` +
+ * `onSortingChange`.
+ *
+ * `manual` (W6-05) turns the row model off for server-side tables: the hook
+ * then never sorts, filters, searches or pages `data` itself — it only holds
+ * and emits state, and `rowCount` sizes the pager.
+ *
+ * Every state slice is plain JSON (arrays and records, no `Set`/`Map`), so it
+ * can be written to a URL or storage as it is. Persisting column visibility is
+ * the consumer's `onColumnVisibilityChange`; the design system never touches
+ * `localStorage`.
+ *
+ * @experimental
+ */
+/** Sort direction of one column; `null` on the sorting slice means unsorted. */
+type DataTableSortDirection = "asc" | "desc";
+/** What a column reads from a row: a property name or a function. */
+type DataTableAccessor<TRow> = keyof TRow | ((row: TRow) => unknown);
+/** A value the built-in comparator orders. `null`/`undefined` always sort last. */
+type DataTableSortValue = string | number | boolean | Date | null | undefined;
+/**
+ * One column of a data table. `id` is the stable key the sorting and
+ * column-visibility slices refer to and the ids for ARIA are derived from.
+ *
+ * @experimental
+ */
+interface DataTableColumn<TRow> {
+    /** Stable identifier: the key in `sorting`, `columnVisibility` and derived DOM ids. */
+    id: string;
+    /** Header content. Any node — not string-only, so a consumer never has to find a column by its text. */
+    header: ReactNode;
+    /** How the cell value is read. Defaults to `row[id]` when `id` is a key of the row. */
+    accessor?: DataTableAccessor<TRow>;
+    /** Cell renderer. Defaults to the accessor value rendered as text by the rendering layer. */
+    cell?: (row: TRow, context: {
+        value: unknown;
+        rowId: string;
+        index: number;
+    }) => ReactNode;
+    /** Whether the header offers sorting. Default `false`. */
+    sortable?: boolean | undefined;
+    /** Custom sort key (e.g. a numeric age behind a "5h ago" label). Defaults to the accessor value. */
+    sortValue?: ((row: TRow) => DataTableSortValue) | undefined;
+    /**
+     * Whether the client-side search reads this column. Default `true` for a
+     * column with an accessor. `searchText` overrides what is read.
+     */
+    searchable?: boolean;
+    /** Text the client-side search matches for this column. Defaults to `String(value)`. */
+    searchText?: (row: TRow) => string;
+    /** Whether the columns menu may hide it. Default `true`. */
+    hideable?: boolean;
+    /** Layout hint for the rendering layer (W6-01 `TableCell align`). */
+    align?: "start" | "center" | "end";
+    /** Layout hint: right-aligned, tabular figures (W6-01 `TableCell numeric`). */
+    numeric?: boolean;
+    /** Layout hint: a CSS width for the column. */
+    width?: string;
+    /**
+     * The direction a first click sorts in (PR 3). Default `"asc"`; dates and
+     * money usually want `"desc"` (newest / largest first). The cycle is then
+     * first → opposite → unsorted.
+     */
+    sortFirstDirection?: DataTableSortDirection | undefined;
+    /** Layout hint: stick the column to an edge while the table scrolls sideways (`TableCell sticky`). */
+    sticky?: "start" | "end" | undefined;
+}
+/**
+ * One filter of a data table: which rows a value keeps, and the options the
+ * rendering layer offers, in the shared {@link Option} model.
+ *
+ * @experimental
+ */
+interface DataTableFilterDefinition<TRow, TValue extends string = string> {
+    id: string;
+    label: string;
+    options: readonly Option<TValue>[];
+    /** `true` keeps the row for the given value. Receives one value at a time, also for a multi-value filter. */
+    match: (row: TRow, value: TValue) => boolean;
+    /** Whether several values may be active (a row matches when any matches). Default `false`. */
+    multiple?: boolean;
+}
+/** Sorting slice: one column and a direction, or `null` for unsorted. */
+interface DataTableSortingState {
+    columnId: string;
+    direction: DataTableSortDirection;
+}
+/** Pagination slice. `page` is 1-based, like `Pagination` and `DataTableView`. */
+interface DataTablePaginationState {
+    page: number;
+    pageSize: number;
+}
+/** Filters slice: filter id → active value(s). A missing key, `null` or `[]` means "all". */
+type DataTableFilterValue = string | readonly string[] | null;
+type DataTableFiltersState = Readonly<Record<string, DataTableFilterValue>>;
+/** Column-visibility slice: column id → shown. A missing key means shown. */
+type DataTableColumnVisibilityState = Readonly<Record<string, boolean>>;
+/** Selection slice: the ids of the selected rows, in selection order. */
+type DataTableSelectionState = readonly string[];
+/**
+ * Multi-sort slice (PR 3): the sort keys in priority order — index 0 is the
+ * primary sort, the one the `sorting` slice mirrors. `[]` is unsorted.
+ */
+type DataTableMultiSortingState = readonly DataTableSortingState[];
+/** Column-order slice: column ids in display order. Ids not listed follow in `columns` order. */
+type DataTableColumnOrderState = readonly string[];
+/** Column-width slice: column id → width in px. A missing key keeps the column's own `width`. */
+type DataTableColumnWidthsState = Readonly<Record<string, number>>;
+/** Column-pinning slice: ids pinned to the start edge, in pin order (they render first). */
+interface DataTableColumnPinningState {
+    start: readonly string[];
+}
+/**
+ * The whole serialisable state of a table, e.g. for a URL or storage mirror.
+ *
+ * @experimental
+ */
+interface DataTableState {
+    sorting: DataTableSortingState | null;
+    pagination: DataTablePaginationState;
+    search: string;
+    selection: DataTableSelectionState;
+    columnVisibility: DataTableColumnVisibilityState;
+    filters: DataTableFiltersState;
+    /**
+     * Every sort key, primary first (PR 3). Always present on the state the hook
+     * reports; optional so a state written before multi-sort still type-checks.
+     */
+    multiSorting?: DataTableMultiSortingState;
+    /** Column display order (PR 3). Always present on reported state. */
+    columnOrder?: DataTableColumnOrderState;
+    /** Column widths in px (PR 3). Always present on reported state. */
+    columnWidths?: DataTableColumnWidthsState;
+    /** Pinned columns (PR 3). Always present on reported state. */
+    columnPinning?: DataTableColumnPinningState;
+}
+/**
+ * Options of {@link useDataTable}. Every slice accepts a controlled value, a
+ * default, and a change callback; the whole-state `state` / `defaultState` /
+ * `onStateChange` triple works alongside (a granular prop wins over `state`).
+ *
+ * @experimental
+ */
+interface UseDataTableOptions<TRow> {
+    /** The rows. In client mode the full set; in `manual` mode the current page as the server returned it. */
+    data: readonly TRow[];
+    columns: readonly DataTableColumn<TRow>[];
+    /** Filter definitions (`filters` is the state). */
+    filterDefinitions?: readonly DataTableFilterDefinition<TRow>[] | undefined;
+    /**
+     * Stable id of a row. Defaults to `row.id` when it is a string or number,
+     * otherwise the row's index (fine for static data; pass one for anything
+     * that reorders).
+     */
+    getRowId?: ((row: TRow, index: number) => string) | undefined;
+    /** Whether a row may be selected. Default: every row. */
+    isRowSelectable?: ((row: TRow) => boolean) | undefined;
+    /** Base id for the derived DOM ids (`getColumnId`, `getRowDomId`). Generated when omitted. */
+    id?: string | undefined;
+    /**
+     * Server mode (W6-05): the hook never sorts, filters, searches or pages
+     * `data` — it only holds and emits state. `rowCount` sizes the pager.
+     * Default `false`.
+     */
+    manual?: boolean | undefined;
+    /** Total number of rows matching the current search and filters, in `manual` mode. Defaults to `data.length`. */
+    rowCount?: number | undefined;
+    /**
+     * Called by `selection.selectAllMatching()` in `manual` mode, where only the
+     * server knows every matching id: receives the current state so the
+     * consumer can resolve the ids and set the selection.
+     */
+    onSelectAllMatching?: ((state: DataTableState) => void) | undefined;
+    /**
+     * Whether changing the search or a filter returns to page 1. Default
+     * `true` (today's `DataTableView`). Sorting never resets the page.
+     */
+    resetPageOnChange?: boolean | undefined;
+    sorting?: DataTableSortingState | null | undefined;
+    defaultSorting?: DataTableSortingState | null | undefined;
+    onSortingChange?: ((sorting: DataTableSortingState | null) => void) | undefined;
+    /**
+     * Allow several sort keys (PR 3): `sorting.toggle(id, { additive: true })`
+     * (a Shift-click) adds or advances a secondary key. Default `false` — an
+     * additive toggle then behaves like a plain one.
+     */
+    multiSort?: boolean | undefined;
+    /** Controlled sort keys, primary first. Wins over `sorting`. */
+    multiSorting?: DataTableMultiSortingState | undefined;
+    defaultMultiSorting?: DataTableMultiSortingState | undefined;
+    onMultiSortingChange?: ((multiSorting: DataTableMultiSortingState) => void) | undefined;
+    columnOrder?: DataTableColumnOrderState | undefined;
+    defaultColumnOrder?: DataTableColumnOrderState | undefined;
+    onColumnOrderChange?: ((columnOrder: DataTableColumnOrderState) => void) | undefined;
+    columnWidths?: DataTableColumnWidthsState | undefined;
+    defaultColumnWidths?: DataTableColumnWidthsState | undefined;
+    onColumnWidthsChange?: ((columnWidths: DataTableColumnWidthsState) => void) | undefined;
+    columnPinning?: DataTableColumnPinningState | undefined;
+    defaultColumnPinning?: DataTableColumnPinningState | undefined;
+    onColumnPinningChange?: ((columnPinning: DataTableColumnPinningState) => void) | undefined;
+    pagination?: DataTablePaginationState | undefined;
+    defaultPagination?: Partial<DataTablePaginationState> | undefined;
+    onPaginationChange?: ((pagination: DataTablePaginationState) => void) | undefined;
+    search?: string | undefined;
+    defaultSearch?: string | undefined;
+    onSearchChange?: ((search: string) => void) | undefined;
+    selection?: DataTableSelectionState | undefined;
+    defaultSelection?: DataTableSelectionState | undefined;
+    onSelectionChange?: ((selection: DataTableSelectionState) => void) | undefined;
+    columnVisibility?: DataTableColumnVisibilityState | undefined;
+    defaultColumnVisibility?: DataTableColumnVisibilityState | undefined;
+    /** The persistence hook for column visibility: write it wherever the product keeps preferences. */
+    onColumnVisibilityChange?: ((columnVisibility: DataTableColumnVisibilityState) => void) | undefined;
+    filters?: DataTableFiltersState | undefined;
+    defaultFilters?: DataTableFiltersState | undefined;
+    onFiltersChange?: ((filters: DataTableFiltersState) => void) | undefined;
+    /** Whole-state control. A granular prop (`sorting`, `search`, …) wins over the matching key. */
+    state?: Partial<DataTableState> | undefined;
+    defaultState?: Partial<DataTableState> | undefined;
+    /** Called with the complete next state after any slice changes. */
+    onStateChange?: ((state: DataTableState) => void) | undefined;
+}
+/** One row of the derived row model. */
+interface DataTableRowModel<TRow> {
+    id: string;
+    row: TRow;
+    /** Index within the rows to render (the current page). */
+    index: number;
+    selected: boolean;
+    selectable: boolean;
+}
+/** `aria-sort` value of a sortable header. `undefined` for a non-sortable column. */
+type DataTableAriaSort = "ascending" | "descending" | "none" | undefined;
+/** Options of `sorting.toggle` (PR 3). */
+interface DataTableSortToggleOptions {
+    /** Add or advance this column as a secondary key instead of replacing the sort (Shift-click). Needs `multiSort`. */
+    additive?: boolean | undefined;
+}
+interface DataTableSortingApi {
+    /** The primary sort key. */
+    value: DataTableSortingState | null;
+    /** Replaces the whole sort with one key (or none). */
+    set: (sorting: DataTableSortingState | null) => void;
+    /** Every sort key, primary first (PR 3). */
+    multi: DataTableMultiSortingState;
+    /** Replaces every sort key (PR 3). */
+    setMulti: (multiSorting: DataTableMultiSortingState) => void;
+    /** Direction of one column, `null` when it is not a sort key. */
+    getDirection: (columnId: string) => DataTableSortDirection | null;
+    /** 1-based priority of a sort key; `0` when the column is not sorted (PR 3). */
+    getIndex: (columnId: string) => number;
+    /**
+     * Advances one column through its cycle: unsorted → first direction →
+     * opposite → unsorted (first direction is the column's
+     * `sortFirstDirection`, default `asc`). A plain toggle replaces the sort; an
+     * `additive` one (with `multiSort`) adds, advances or drops a secondary key.
+     */
+    toggle: (columnId: string, options?: DataTableSortToggleOptions) => void;
+    /**
+     * `aria-sort` for a header: `"ascending"`/`"descending"` on the primary key
+     * only — ARIA expects one sorted header at a time — `"none"` for any other
+     * sortable column, secondary keys included (their rank is in the header's
+     * own text, see `TableHead sortIndex`).
+     */
+    getAriaSort: (columnId: string) => DataTableAriaSort;
+}
+/** Column-order API (PR 3). */
+interface DataTableColumnOrderApi {
+    /** Every column id in display order (resolved: unlisted ids appended). */
+    value: DataTableColumnOrderState;
+    set: (columnOrder: DataTableColumnOrderState) => void;
+    /** Moves a column `delta` places among the rendered columns (`-1` left, `1` right). No-op at an edge or across the pinned boundary. */
+    move: (columnId: string, delta: number) => void;
+    /** Whether `move(columnId, delta)` would move it. */
+    canMove: (columnId: string, delta: number) => boolean;
+    /** Back to the `columns` order. */
+    reset: () => void;
+}
+/** Column-width API (PR 3). */
+interface DataTableColumnWidthsApi {
+    value: DataTableColumnWidthsState;
+    /** Width in px set by the user, or `undefined` (the column's own `width`). */
+    get: (columnId: string) => number | undefined;
+    set: (columnId: string, width: number) => void;
+    /** Clears one column's width (autosize), or every width without an argument. */
+    reset: (columnId?: string) => void;
+}
+/** Column-pinning API (PR 3). */
+interface DataTableColumnPinningApi {
+    value: DataTableColumnPinningState;
+    isPinned: (columnId: string) => boolean;
+    pin: (columnId: string) => void;
+    unpin: (columnId: string) => void;
+    set: (columnPinning: DataTableColumnPinningState) => void;
+    reset: () => void;
+}
+interface DataTablePaginationApi extends DataTablePaginationState {
+    pageCount: number;
+    /** Total rows matching the search and filters (`rowCount` in manual mode). */
+    rowCount: number;
+    /** 1-based index of the first and last row on the page; both `0` when empty. */
+    rangeStart: number;
+    rangeEnd: number;
+    canPreviousPage: boolean;
+    canNextPage: boolean;
+    set: (pagination: DataTablePaginationState) => void;
+    setPage: (page: number) => void;
+    /** Changes the page size and returns to page 1. */
+    setPageSize: (pageSize: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+}
+interface DataTableSearchApi {
+    value: string;
+    set: (search: string) => void;
+    clear: () => void;
+}
+interface DataTableSelectionApi {
+    value: DataTableSelectionState;
+    count: number;
+    isSelected: (rowId: string) => boolean;
+    set: (selection: DataTableSelectionState) => void;
+    select: (rowId: string) => void;
+    deselect: (rowId: string) => void;
+    toggle: (rowId: string) => void;
+    clear: () => void;
+    /** Every selectable row on the current page is selected (false when there is none). */
+    allPageSelected: boolean;
+    /** Some, but not all, selectable rows on the current page are selected (the header checkbox's indeterminate). */
+    somePageSelected: boolean;
+    /** Selects (or clears) the selectable rows on the current page, keeping selections made elsewhere. */
+    selectPage: () => void;
+    deselectPage: () => void;
+    togglePage: () => void;
+    /**
+     * Selects every row matching the search and filters. In client mode the
+     * hook knows them; in `manual` mode it calls `onSelectAllMatching(state)`.
+     */
+    selectAllMatching: () => void;
+}
+interface DataTableColumnVisibilityApi {
+    value: DataTableColumnVisibilityState;
+    isVisible: (columnId: string) => boolean;
+    set: (columnVisibility: DataTableColumnVisibilityState) => void;
+    setVisible: (columnId: string, visible: boolean) => void;
+    toggle: (columnId: string) => void;
+    /** Shows every column again. */
+    reset: () => void;
+}
+interface DataTableFiltersApi<TRow> {
+    value: DataTableFiltersState;
+    definitions: readonly DataTableFilterDefinition<TRow>[];
+    /** Active value(s) of one filter; `null` when it is not narrowing. */
+    get: (filterId: string) => DataTableFilterValue;
+    set: (filterId: string, value: DataTableFilterValue) => void;
+    clear: (filterId: string) => void;
+    clearAll: () => void;
+    /** Number of filters that are narrowing. */
+    activeCount: number;
+}
+/**
+ * What {@link useDataTable} returns.
+ *
+ * @experimental
+ */
+interface DataTableController<TRow> {
+    /** Base id of the derived DOM ids. */
+    id: string;
+    manual: boolean;
+    /** The whole serialisable state. */
+    state: DataTableState;
+    /** Every column, in order. */
+    allColumns: readonly DataTableColumn<TRow>[];
+    /** The columns to render: `allColumns` in `columnOrder`, pinned first, minus the hidden ones. */
+    columns: readonly DataTableColumn<TRow>[];
+    /** The rows to render: filtered → searched → sorted → paged (client mode), or `data` as given (manual mode). */
+    rows: readonly DataTableRowModel<TRow>[];
+    /**
+     * Every row matching the search and filters, sorted, across all pages
+     * (client mode) — the scope of `selection.selectAllMatching()`; `data` as
+     * given in manual mode.
+     */
+    matchingRows: readonly TRow[];
+    /** Reads a cell through the column's accessor. */
+    getCellValue: (row: TRow, column: DataTableColumn<TRow>) => unknown;
+    /** Renders a cell: the column's `cell`, or the accessor value as text. */
+    renderCell: (model: DataTableRowModel<TRow>, column: DataTableColumn<TRow>) => ReactNode;
+    /** Stable DOM id for a column's header cell (`aria-describedby`, `headers`). */
+    getColumnId: (columnId: string) => string;
+    /** Stable DOM id for a row. */
+    getRowDomId: (rowId: string) => string;
+    sorting: DataTableSortingApi;
+    pagination: DataTablePaginationApi;
+    search: DataTableSearchApi;
+    selection: DataTableSelectionApi;
+    columnVisibility: DataTableColumnVisibilityApi;
+    filters: DataTableFiltersApi<TRow>;
+    /** Column order (PR 3). */
+    columnOrder: DataTableColumnOrderApi;
+    /** Column widths (PR 3). */
+    columnWidths: DataTableColumnWidthsApi;
+    /** Column pinning (PR 3). */
+    columnPinning: DataTableColumnPinningApi;
+    /** Resets order, widths, pinning and visibility in one change (a header menu's "Reset columns"). */
+    resetColumns: () => void;
+}
+/**
+ * The comparator `DataTableView` uses today: case-insensitive strings,
+ * numbers and dates by value, `null`/`undefined` last in both directions.
+ */
+declare function compareSortValues(a: DataTableSortValue, b: DataTableSortValue, direction: DataTableSortDirection): number;
+/**
+ * Advances through the header cycle: unsorted → `first` → opposite →
+ * unsorted. `first` defaults to `asc` (today's cycle).
+ */
+declare function nextSortDirection(current: DataTableSortDirection | null, first?: DataTableSortDirection): DataTableSortDirection | null;
+/**
+ * The headless data-table controller. See the module comment and
+ * `docs/data-tables.md`.
+ *
+ * @experimental
+ */
+declare function useDataTable<TRow>(options: UseDataTableOptions<TRow>): DataTableController<TRow>;
+
 /**
  * Practice service tones for the client portal. Each engagement surface
  * (card, ring, timeline) is "toned per service": a fill color + a track
@@ -1045,6 +1625,10 @@ interface DataTableProps extends React.HTMLAttributes<HTMLDivElement> {
     /** When true, renders the table card with a flat top edge so it
      *  visually attaches to a `<DataTableToolbar>` above it. */
     withToolbar?: boolean;
+    /** Keep column headers visible inside the scrolling frame. @experimental */
+    stickyHeader?: boolean | undefined;
+    /** Accessible name for the frame when it overflows. Defaults to the table region message. @experimental */
+    regionLabel?: string | undefined;
 }
 /**
  * DataTable — outer wrapper. Children are typically:
@@ -1110,8 +1694,14 @@ interface DataTableHeaderProps extends Omit<TableHeadProps, "sort" | "onSortChan
     /** Optional controlled sort state. When provided, `onSortChange` should
      *  also be wired up — the header becomes fully controlled. */
     sort?: SortDirection | null;
-    /** Fires whenever the user clicks a sortable header. */
-    onSortChange?: (sort: SortDirection | null) => void;
+    /** Fires whenever the user clicks a sortable header. The second argument
+     *  (PR 3) is `{ additive }` — Shift was held, so a multi-sort table adds a
+     *  secondary key. */
+    onSortChange?: (sort: SortDirection | null, meta: TableSortChangeMeta) => void;
+    /** 1-based rank in a multi-key sort (PR 3); shown beside the indicator. @experimental */
+    sortIndex?: number | undefined;
+    /** Direction an unsorted column starts in (PR 3). Default `asc`. @experimental */
+    sortFirstDirection?: SortDirection | undefined;
 }
 /**
  * DataTableHeader — `<th scope="col">`; alias of `TableHead` that keeps the
@@ -1174,6 +1764,104 @@ interface DataTableCheckboxProps extends Omit<DataTableCellProps, "onChange" | "
  * column with no right padding to match `.row-checkbox` in the spec.
  */
 declare const DataTableCheckbox: React$1.ForwardRefExoticComponent<DataTableCheckboxProps & React$1.RefAttributes<HTMLTableCellElement>>;
+/** DataTableCellSecondary — alias of `TableCellSecondary`: a second line shown only in comfortable density (PR 3). */
+type DataTableCellSecondaryProps = TableCellSecondaryProps;
+declare const DataTableCellSecondary: React$1.ForwardRefExoticComponent<TableCellSecondaryProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+/** {@link useDataTableVirtualRows} options. @experimental */
+interface UseDataTableVirtualRowsOptions {
+    /** Rows loaded so far. */
+    count: number;
+    /** The one scroll region (a `Table` wrapper or a `ListPageScroll`). */
+    getScrollElement: () => HTMLElement | null;
+    /** First-guess row height in px; real heights are measured. Default `44` (`--table-row-height`). */
+    estimateSize?: ((index: number) => number) | undefined;
+    /** Rows kept mounted beyond the viewport on each side. Default `15`. */
+    overscan?: number | undefined;
+    getItemKey?: ((index: number) => string | number) | undefined;
+}
+/** What {@link useDataTableVirtualRows} returns. @experimental */
+interface DataTableVirtualRows {
+    /** The rows to render: `index` into your data, and `key`. */
+    items: readonly {
+        index: number;
+        key: string | number;
+        start: number;
+    }[];
+    /** Height of the spacer row before the first rendered row. */
+    paddingTop: number;
+    /** Height of the spacer row after the last rendered row. */
+    paddingBottom: number;
+    totalSize: number;
+    /** Ref callback for each rendered `<tr>` (needs `data-index={item.index}`). */
+    measureElement: (element: Element | null) => void;
+    scrollToIndex: (index: number) => void;
+}
+/**
+ * Windowed rows for a `<table>`: render `paddingTop` / `paddingBottom` as
+ * `DataTableSpacerRow`s around `items`.
+ *
+ * @experimental
+ */
+declare function useDataTableVirtualRows({ count, getScrollElement, estimateSize, overscan, getItemKey, }: UseDataTableVirtualRowsOptions): DataTableVirtualRows;
+/** @experimental */
+interface DataTableSpacerRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /** Spacer height in px; renders nothing at 0. */
+    height: number;
+    /** The table's column count. */
+    colSpan: number;
+}
+/**
+ * DataTableSpacerRow — the empty, `aria-hidden` row that stands in for the
+ * rows a virtualised table has not mounted.
+ *
+ * @experimental
+ */
+declare const DataTableSpacerRow: React$1.ForwardRefExoticComponent<DataTableSpacerRowProps & React$1.RefAttributes<HTMLTableRowElement>>;
+/** @experimental */
+interface DataTableLoadMoreProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** More rows exist beyond what is loaded. */
+    hasMore: boolean;
+    /** A page is in flight — the sentinel and button do not fire again. */
+    loading?: boolean | undefined;
+    /** Failed page message. Pauses automatic loading; the visible retry button remains available. */
+    error?: ReactNode;
+    /** Fetch the next page (cursor, offset — the consumer's business). */
+    onLoadMore: () => void;
+    /** Rows loaded so far, for the end-of-list status. */
+    loadedCount?: number | undefined;
+    /** Total matching rows, when known: "240 of 1,240 loaded". */
+    totalCount?: number | undefined;
+    /** The scroll region the sentinel is observed in. Default: the viewport. */
+    root?: RefObject<HTMLElement | null> | undefined;
+    /** How far before the end to start loading. Default `400px`. */
+    rootMargin?: string | undefined;
+    locale?: string | undefined;
+}
+/**
+ * DataTableLoadMore — the foot of an infinite list: a sentinel that loads
+ * the next page as it scrolls into view, a visible "Load more" button for
+ * keyboard and no-IntersectionObserver users, and a polite status ("All 1,240
+ * loaded" / "240 of 1,240 loaded").
+ *
+ * @experimental
+ */
+declare const DataTableLoadMore: React$1.ForwardRefExoticComponent<DataTableLoadMoreProps & React$1.RefAttributes<HTMLDivElement>>;
+/** {@link useScrollRestoration} options. @experimental */
+interface UseScrollRestorationOptions {
+    /** Restore only once this is true — e.g. once the restored rows are loaded. Default `true`. */
+    ready?: boolean | undefined;
+    /** Storage. Default `sessionStorage` (per tab, cleared with it). */
+    storage?: Pick<Storage, "getItem" | "setItem"> | undefined;
+}
+/**
+ * Saves a scroll region's `scrollTop` under `key` and restores it once on
+ * mount (after `ready`), so "back" from a record returns to the same rows.
+ * SSR-safe: storage is read only in an effect.
+ *
+ * @experimental
+ */
+declare function useScrollRestoration(key: string, ref: RefObject<HTMLElement | null>, options?: UseScrollRestorationOptions): void;
 
 /**
  * DataTableView — config-driven table on top of the composition
@@ -1209,6 +1897,16 @@ interface DataTableViewColumn<Row extends TableRowData> {
     sortValue?: (row: Row) => string | number | null | undefined;
     /** Custom cell renderer; defaults to the raw field value. */
     render?: (row: Row) => ReactNode;
+    /** Right-aligned tabular figures for money and counts (PR 3). @experimental */
+    numeric?: boolean | undefined;
+    /** A second, quieter line under the cell, shown only in the Detailed density (PR 3). @experimental */
+    secondary?: ((row: Row) => ReactNode) | undefined;
+    /** Direction an unsorted column starts in — `desc` for dates and money (PR 3). @experimental */
+    sortFirstDirection?: SortDirection | undefined;
+    /** `false` keeps the column out of the header menu's Hide (PR 3). Default `true`. @experimental */
+    hideable?: boolean | undefined;
+    /** A group's subtotal for this column, under it in each group header (PR 3). @experimental */
+    subtotal?: ((rows: readonly Row[]) => ReactNode) | undefined;
 }
 interface DataTableViewFilter<Row extends TableRowData> {
     key: string;
@@ -1297,8 +1995,63 @@ interface DataTableViewProps<Row extends TableRowData> {
     /** Opt in to row selection. Omit it and the table renders exactly as before. */
     selection?: DataTableViewSelection<Row>;
     className?: string;
+    /** Show all loaded rows and a lazy-load sentinel inside this scroll frame instead of numbered pagination. @experimental */
+    loadMore?: Omit<DataTableLoadMoreProps, "root"> | undefined;
+    /** Shift-click (Shift+Enter) a header to add a ranked secondary sort. @experimental */
+    multiSort?: boolean | undefined;
+    /** Controlled sort keys, primary first (with `multiSort`). @experimental */
+    multiSorting?: DataTableMultiSortingState | undefined;
+    onMultiSortingChange?: ((multiSorting: DataTableMultiSortingState) => void) | undefined;
+    /** A per-column options menu (sort, move, hide, pin, autosize, reset) in each header. @experimental */
+    columnMenu?: boolean | undefined;
+    /** Pointer and keyboard column resize. @experimental */
+    resizableColumns?: boolean | undefined;
+    /** Column ids in display order. @experimental */
+    columnOrder?: DataTableColumnOrderState | undefined;
+    defaultColumnOrder?: DataTableColumnOrderState | undefined;
+    onColumnOrderChange?: ((columnOrder: DataTableColumnOrderState) => void) | undefined;
+    /** Column id → shown. @experimental */
+    columnVisibility?: DataTableColumnVisibilityState | undefined;
+    defaultColumnVisibility?: DataTableColumnVisibilityState | undefined;
+    onColumnVisibilityChange?: ((columnVisibility: DataTableColumnVisibilityState) => void) | undefined;
+    /** Column id → width in px (with `resizableColumns`). @experimental */
+    columnWidths?: DataTableColumnWidthsState | undefined;
+    defaultColumnWidths?: DataTableColumnWidthsState | undefined;
+    onColumnWidthsChange?: ((columnWidths: DataTableColumnWidthsState) => void) | undefined;
+    /** Columns pinned to the start edge. @experimental */
+    columnPinning?: DataTableColumnPinningState | undefined;
+    defaultColumnPinning?: DataTableColumnPinningState | undefined;
+    onColumnPinningChange?: ((columnPinning: DataTableColumnPinningState) => void) | undefined;
+    /**
+     * Keep the first column in view while the table scrolls sideways. With
+     * `selection` the first column is the checkbox column. @experimental
+     */
+    stickyFirstColumn?: boolean | undefined;
+    /** Keep column headers visible while this frame scrolls vertically. @experimental */
+    stickyHeader?: boolean | undefined;
+    /** Accessible name for the keyboard-scrollable region, present only when overflowing. @experimental */
+    regionLabel?: string | undefined;
+    /** Row density scope; `compact` hides each column's `secondary` line. @experimental */
+    density?: ThemeDensity | undefined;
+    /**
+     * Group the current page's rows by this dimension (a `DisplayMenu` grouping
+     * value); `null` / `"none"` is ungrouped. Groups render as collapsible
+     * `TableGroupRow`s with a count and each column's `subtotal`. @experimental
+     */
+    groupBy?: string | null | undefined;
+    /** A row's group under `groupBy`. Default: the `groupBy` field as text. @experimental */
+    getGroupKey?: ((row: Row, groupBy: string) => string) | undefined;
+    /** A group header's label. Default: the group key. @experimental */
+    renderGroupLabel?: ((groupKey: string, rows: readonly Row[]) => ReactNode) | undefined;
+    /** Order of the groups. Default: first met. @experimental */
+    compareGroups?: ((a: string, b: string) => number) | undefined;
+    collapsedGroups?: readonly string[] | undefined;
+    defaultCollapsedGroups?: readonly string[] | undefined;
+    onCollapsedGroupsChange?: ((collapsed: readonly string[]) => void) | undefined;
+    /** Remember collapsed groups per dimension under this key. @experimental */
+    groupPersistKey?: string | undefined;
 }
-declare function DataTableView<Row extends TableRowData>({ columns, data, filters, searchKeys, searchPlaceholder, initialSort, sorting: sortingProp, onSortingChange, page: pageProp, onPageChange, search: searchProp, onSearchChange, onRowClick, rowKey, pageSize, hideOnSinglePage, itemLabel, selection, className, }: DataTableViewProps<Row>): react_jsx_runtime.JSX.Element;
+declare function DataTableView<Row extends TableRowData>({ columns, data, filters, searchKeys, searchPlaceholder, initialSort, sorting: sortingProp, onSortingChange, page: pageProp, onPageChange, search: searchProp, onSearchChange, onRowClick, rowKey, pageSize, hideOnSinglePage, itemLabel, selection, className, loadMore, multiSort, multiSorting, onMultiSortingChange, columnMenu, resizableColumns, columnOrder, defaultColumnOrder, onColumnOrderChange, columnVisibility, defaultColumnVisibility, onColumnVisibilityChange, columnWidths, defaultColumnWidths, onColumnWidthsChange, columnPinning, defaultColumnPinning, onColumnPinningChange, stickyFirstColumn, stickyHeader, regionLabel, density, groupBy, getGroupKey, renderGroupLabel, compareGroups, collapsedGroups, defaultCollapsedGroups, onCollapsedGroupsChange, groupPersistKey, }: DataTableViewProps<Row>): react_jsx_runtime.JSX.Element;
 /**
  * EmptyValue — the em-dash placeholder for a cell with no value. Generic:
  * no copy, no product tone.
@@ -1359,4 +2112,4 @@ declare function MoneyCell({ value }: {
     value?: number | null;
 }): react_jsx_runtime.JSX.Element;
 
-export { type DataTableProps as $, Assignee as A, type BadgeProps as B, type CardSlot as C, Dash as D, DataTable as E, type FileKind as F, DataTableBody as G, type DataTableBodyProps as H, type InputSlot as I, DataTableCell as J, DataTableCellDue as K, type DataTableCellDueProps as L, MoneyCell as M, type NumberInputSlot as N, DataTableCellId as O, type PhoneFieldSlot as P, DataTableCellMono as Q, DataTableCellName as R, type SelectSize as S, TagsCell as T, type DataTableCellProps as U, DataTableCheckbox as V, type DataTableCheckboxProps as W, DataTableHead as X, type DataTableHeadProps as Y, DataTableHeader as Z, type DataTableHeaderProps as _, type ServiceTone as a, type TableBodyProps as a$, DataTableResultsCount as a0, type DataTableResultsCountProps as a1, DataTableRow as a2, type DataTableRowProps as a3, DataTableSearch as a4, type DataTableSearchProps as a5, DataTableSpacer as a6, type DataTableSpacerProps as a7, DataTableToolbar as a8, type DataTableToolbarProps as a9, SelectContent as aA, type SelectContentProps as aB, SelectGroup as aC, SelectItem as aD, SelectLabel as aE, type SelectOption as aF, type SelectProps as aG, SelectRoot as aH, SelectScrollDownButton as aI, SelectScrollUpButton as aJ, SelectSeparator as aK, type SelectSlot as aL, SelectTrigger as aM, type SelectTriggerProps as aN, SelectValue as aO, type SheetSlot as aP, type ShellSlot as aQ, type SideDrawerSlot as aR, type SidebarBrandSwitcherSlot as aS, type SidebarSlot as aT, type SortDirection as aU, type StackSlot as aV, type StatusBadgeSlot as aW, type SurfaceSlot as aX, type SwitchSlot as aY, Table as aZ, TableBody as a_, DataTableView as aa, type DataTableViewColumn as ab, type DataTableViewFilter as ac, type DataTableViewProps as ad, type DataTableViewSelection as ae, type DataTableViewSort as af, type DialogSlot as ag, type DropdownMenuSlot as ah, EmptyValue as ai, type FieldSlot as aj, type FieldsetSlot as ak, FileChip as al, type FileChipProps as am, type HeadingSlot as an, type IconButtonSlot as ao, type InlineSlot as ap, type KbdSlot as aq, type LabelSlot as ar, type LinkButtonSlot as as, type PaginationSlot as at, type PopoverSlot as au, type PressableSlot as av, type RadioGroupSlot as aw, SERVICE_TONES as ax, Select as ay, type SelectClassNames as az, StagePill as b, TableCaption as b0, type TableCaptionProps as b1, TableCell as b2, type TableCellAlign as b3, type TableCellCommonProps as b4, type TableCellProps as b5, TableFooter as b6, type TableFooterProps as b7, TableGroupRow as b8, type TableGroupRowProps as b9, TableHead as ba, type TableHeadProps as bb, TableHeader as bc, type TableHeaderProps as bd, type TableHeaderStyle as be, TableRow as bf, type TableRowData as bg, type TableRowProps as bh, type TableSlot as bi, type TableSortDirection as bj, type TableStickyEdge as bk, type TableTone as bl, type TextSlot as bm, type ThemeBrand as bn, type ThemeDirection as bo, type ThemeScheme as bp, ThemeScope as bq, type ThemeScopeProps as br, type ThemeScopeValue as bs, type ToastSlot as bt, type TooltipSlot as bu, badgeVariants as bv, resolveBadgeAppearance as bw, serviceToneLabel as bx, serviceToneStyle as by, type AvatarSlot as c, type FileUploadSlot as d, type SearchInputSlot as e, type ThemeDensity as f, type TextareaSlot as g, type BadgeSize as h, type BadgeShape as i, type DataTableSlot as j, type TableProps as k, type AlertDialogSlot as l, Badge as m, type BadgeAppearance as n, type BadgeAppearanceInput as o, type BadgeLegacyVariant as p, type BadgeSlot as q, type BadgeVariant as r, type BadgeVariantsProps as s, type ButtonSlot as t, type CheckboxSlot as u, type ChipSlot as v, type CodeSlot as w, type ComboboxSlot as x, type CommandSlot as y, type ContextMenuSlot as z };
+export { DataTableCheckbox as $, Assignee as A, type BadgeProps as B, type CardSlot as C, Dash as D, type CommandSlot as E, type FileKind as F, type ContextMenuSlot as G, DataTable as H, type InputSlot as I, type DataTableAccessor as J, type DataTableAriaSort as K, DataTableBody as L, MoneyCell as M, type NumberInputSlot as N, type DataTableBodyProps as O, type PhoneFieldSlot as P, DataTableCell as Q, DataTableCellDue as R, type SelectSize as S, TagsCell as T, type DataTableCellDueProps as U, DataTableCellId as V, DataTableCellMono as W, DataTableCellName as X, type DataTableCellProps as Y, DataTableCellSecondary as Z, type DataTableCellSecondaryProps as _, type ServiceTone as a, type KbdSlot as a$, type DataTableCheckboxProps as a0, type DataTableColumn as a1, type DataTableColumnOrderApi as a2, type DataTableColumnOrderState as a3, type DataTableColumnPinningApi as a4, type DataTableColumnPinningState as a5, type DataTableColumnVisibilityApi as a6, type DataTableColumnVisibilityState as a7, type DataTableColumnWidthsApi as a8, type DataTableColumnWidthsState as a9, type DataTableSortingApi as aA, type DataTableSortingState as aB, DataTableSpacer as aC, type DataTableSpacerProps as aD, DataTableSpacerRow as aE, type DataTableSpacerRowProps as aF, type DataTableState as aG, DataTableToolbar as aH, type DataTableToolbarProps as aI, DataTableView as aJ, type DataTableViewColumn as aK, type DataTableViewFilter as aL, type DataTableViewProps as aM, type DataTableViewSelection as aN, type DataTableViewSort as aO, type DataTableVirtualRows as aP, type DialogSlot as aQ, type DropdownMenuSlot as aR, EmptyValue as aS, type FieldSlot as aT, type FieldsetSlot as aU, FileChip as aV, type FileChipProps as aW, type FilterChipsSlot as aX, type HeadingSlot as aY, type IconButtonSlot as aZ, type InlineSlot as a_, type DataTableFilterDefinition as aa, type DataTableFilterValue as ab, type DataTableFiltersApi as ac, type DataTableFiltersState as ad, DataTableHead as ae, type DataTableHeadProps as af, DataTableHeader as ag, type DataTableHeaderProps as ah, DataTableLoadMore as ai, type DataTableLoadMoreProps as aj, type DataTableMultiSortingState as ak, type DataTablePaginationApi as al, type DataTablePaginationState as am, type DataTableProps as an, DataTableResultsCount as ao, type DataTableResultsCountProps as ap, DataTableRow as aq, type DataTableRowProps as ar, DataTableSearch as as, type DataTableSearchApi as at, type DataTableSearchProps as au, type DataTableSelectionApi as av, type DataTableSelectionState as aw, type DataTableSortDirection as ax, type DataTableSortToggleOptions as ay, type DataTableSortValue as az, StagePill as b, type TableStickyEdge as b$, type LabelSlot as b0, type LinkButtonSlot as b1, type ListPageSlot as b2, type PaginationSlot as b3, type PopoverSlot as b4, type PressableSlot as b5, type RadioGroupSlot as b6, SERVICE_TONES as b7, Select as b8, type SelectClassNames as b9, Table as bA, TableBody as bB, type TableBodyProps as bC, TableCaption as bD, type TableCaptionProps as bE, TableCell as bF, type TableCellAlign as bG, type TableCellCommonProps as bH, type TableCellProps as bI, TableCellSecondary as bJ, type TableCellSecondaryProps as bK, TableFooter as bL, type TableFooterProps as bM, TableGroupRow as bN, type TableGroupRowProps as bO, type TableGroupRowSubtotal as bP, TableHead as bQ, type TableHeadProps as bR, TableHeader as bS, type TableHeaderProps as bT, type TableHeaderStyle as bU, TableRow as bV, type TableRowData as bW, type TableRowProps as bX, type TableSlot as bY, type TableSortChangeMeta as bZ, type TableSortDirection as b_, SelectContent as ba, type SelectContentProps as bb, SelectGroup as bc, SelectItem as bd, SelectLabel as be, type SelectOption as bf, type SelectProps as bg, SelectRoot as bh, SelectScrollDownButton as bi, SelectScrollUpButton as bj, SelectSeparator as bk, type SelectSlot as bl, SelectTrigger as bm, type SelectTriggerProps as bn, SelectValue as bo, type SheetSlot as bp, type ShellSlot as bq, type SideDrawerSlot as br, type SidebarBrandSwitcherSlot as bs, type SidebarSlot as bt, type SortDirection as bu, type StackSlot as bv, type StatStripSlot as bw, type StatusBadgeSlot as bx, type SurfaceSlot as by, type SwitchSlot as bz, type AvatarSlot as c, type TableTone as c0, type TextSlot as c1, type ThemeBrand as c2, type ThemeDirection as c3, type ThemeScheme as c4, ThemeScope as c5, type ThemeScopeProps as c6, type ThemeScopeValue as c7, type ToastSlot as c8, type TooltipSlot as c9, type UseDataTableOptions as ca, type UseDataTableVirtualRowsOptions as cb, type UseScrollRestorationOptions as cc, badgeVariants as cd, compareSortValues as ce, nextSortDirection as cf, resolveBadgeAppearance as cg, serviceToneLabel as ch, serviceToneStyle as ci, useDataTable as cj, useDataTableVirtualRows as ck, useScrollRestoration as cl, type FileUploadSlot as d, type SearchInputSlot as e, type ThemeDensity as f, type TextareaSlot as g, type BadgeSize as h, type BadgeShape as i, type DataTableController as j, type DataTableSlot as k, type TableProps as l, type DataTableRowModel as m, type AlertDialogSlot as n, Badge as o, type BadgeAppearance as p, type BadgeAppearanceInput as q, type BadgeLegacyVariant as r, type BadgeSlot as s, type BadgeVariant as t, type BadgeVariantsProps as u, type ButtonSlot as v, type CheckboxSlot as w, type ChipSlot as x, type CodeSlot as y, type ComboboxSlot as z };