@rozie-ui/data-table-solid 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,566 @@
+import { JSX } from "solid-js";
+
+//#region src/DataTable.d.ts
+interface GroupBarSlotCtx {
+  grouping: any;
+  groupableColumns: any;
+  applyGrouping: any;
+  clearGrouping: any;
+}
+interface SelectAllSlotCtx {
+  checked: any;
+  indeterminate: any;
+  toggle: any;
+}
+interface ColHeaderSlotCtx {
+  columnId: any;
+  column: any;
+  label: any;
+}
+interface FilterSlotCtx {
+  columnId: any;
+  value: any;
+  uniqueValues: any;
+  minMax: any;
+  setFilter: any;
+}
+interface SelectCellSlotCtx {
+  row: any;
+  checked: any;
+  toggle: any;
+}
+interface CellSlotCtx {
+  columnId: any;
+  column: any;
+  row: any;
+  value: any;
+}
+interface EditorSlotCtx {
+  columnId: any;
+  column: any;
+  row: any;
+  value: any;
+  commit: any;
+  cancel: any;
+}
+interface DetailSlotCtx {
+  row: any;
+}
+interface DataTableProps {
+  /**
+   * The row data — `model: true`, so a committed cell/row edit writes a **fresh** array back through `r-model:data` (uncontrolled fallback `dataDefault`). A stable reference per Rozie's setup-once model — fed directly into table-core (never map/cloned in the watcher).
+   * @example
+   * <DataTable r-model:data="rows" :columns="cols" />
+   */
+  data: any[];
+  defaultData?: any[];
+  onDataChange?: (data: any[]) => void;
+  /**
+   * Config-array column fallback (lower precedence than `<Column>` children). Each entry: `{ id?, field, header?, sortable?, filterable?, pinned?, width? }`. Columns may come from this array, from `<Column>` children, or both (id-keyed last-write-wins union).
+   */
+  columns?: any[];
+  /**
+   * Row-selection mode: `'none'` | `'single'` | `'multiple'`. `'multiple'` auto-injects a leading checkbox column with a select-all header.
+   */
+  selectionMode?: string;
+  /**
+   * `SortingState` — `[{ id, desc }]`. Uncontrolled fallback when unbound. Two-way: writes funnel a fresh value through the `sort-change` event regardless of binding.
+   */
+  sorting?: any[];
+  defaultSorting?: any[];
+  onSortingChange?: (sorting: any[]) => void;
+  /**
+   * The global search string — narrows all columns. Feeds `getFilteredRowModel()`. Surfaces through `filter-change`. Two-way: fires `filter-change` regardless of binding.
+   */
+  globalFilter?: string;
+  defaultGlobalFilter?: string;
+  onGlobalFilterChange?: (globalFilter: string) => void;
+  /**
+   * `ColumnFiltersState` — `[{ id, value }]` per-column narrowing (gated by each column's `filterable`). Two-way: whole-array replace on write, fires `filter-change`.
+   */
+  columnFilters?: any[];
+  defaultColumnFilters?: any[];
+  onColumnFiltersChange?: (columnFilters: any[]) => void;
+  /**
+   * `{ pageIndex, pageSize }`. Defaults to `{ pageIndex: 0, pageSize: 10 }`; feeds the prev/next + page-size chrome (and `getPaginationRowModel()`). Two-way: funnels a fresh object through `page-change`.
+   */
+  pagination?: Record<string, any>;
+  defaultPagination?: Record<string, any>;
+  onPaginationChange?: (pagination: Record<string, any>) => void;
+  /**
+   * Server-side hook: sets `manualPagination` / `manualFiltering` / `manualSorting` so table-core trusts the consumer-supplied rows and only emits the change events (the consumer fetches each page).
+   */
+  manual?: boolean;
+  /**
+   * Total server-side row count for `manual` pagination; lets the table compute page count when it doesn't hold the full dataset.
+   */
+  rowCount?: (number) | null;
+  /**
+   * Explicit total page count for `manual` pagination; overrides rowCount-derived count.
+   */
+  pageCount?: (number) | null;
+  /**
+   * Opt-in **expandable rows**. When `true`, a leading chevron expander column auto-injects (after the select column) and `getExpandedRowModel` activates; default `false` is byte-identical-off. Every row can expand to reveal a `#detail` panel unless `getSubRows` is supplied (then only rows with children expand). Bind `:expandable="true"` (a bare attr only coerces on Vue+Lit).
+   */
+  expandable?: boolean;
+  /**
+   * `ExpandedState` — `{ [rowId]: true }`, or the `true` literal after `expandAll` (declared `type: [Object, Boolean]`). Multi-expand (multiple rows open at once). Surfaces through `expand-change`; uncontrolled fallback (`$data.expandedDefault`) when unbound — the default is `null` so the uncontrolled fallback AND the grouping auto-expand default are reachable (a non-null default would short-circuit them). When grouping is active and `expanded` is untouched, group subtrees auto-expand.
+   */
+  expanded?: (Record<string, any> | boolean) | null;
+  defaultExpanded?: (Record<string, any> | boolean) | null;
+  onExpandedChange?: (expanded: (Record<string, any> | boolean) | null) => void;
+  /**
+   * Table-level child-row accessor `(originalRow, index) => TData[] | undefined` that drives nested sub-rows. When supplied (with `expandable`), table-core flattens the hierarchy and the expand seam reveals depth-indented child rows. Null → the `#detail` scoped slot is the expand mode.
+   */
+  getSubRows?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * Opt-in gate for the **headless `#groupBar`** host region. Default `false` is byte-identical-off. `getGroupedRowModel` is wired unconditionally (inert when `grouping` is empty), so grouping is driven by the `grouping` model; this flag only gates the consumer-facing group-bar surface (the component ships **no** built-in drag UI).
+   */
+  groupable?: boolean;
+  /**
+   * `GroupingState` — an ordered `string[]` of column ids (multi-column → nested groups, e.g. `['region','category']`). An empty/unbound list is ungrouped (byte-identical-off). Group-header rows are collapsible (they ride the expand model). Surfaces through `group-change`; uncontrolled fallback (`$data.groupingDefault`, default `[]`) when unbound — the default is `null` (mirroring `expanded`) so the uncontrolled fallback is reachable and the grouping auto-expand default can activate when a consumer applies grouping without binding `r-model:grouping` (a non-null `[]` default would short-circuit it). All reads are null-guarded, so table-core still receives an array.
+   */
+  grouping?: (any[]) | null;
+  defaultGrouping?: (any[]) | null;
+  onGroupingChange?: (grouping: (any[]) | null) => void;
+  /**
+   * `RowSelectionState` — `{ [rowId]: true }`. Checkbox-only toggle (the row body does not select). Driven by the `selectionMode` chrome. Two-way: fires `selection-change` regardless of binding.
+   */
+  rowSelection?: Record<string, any>;
+  defaultRowSelection?: Record<string, any>;
+  onRowSelectionChange?: (rowSelection: Record<string, any>) => void;
+  /**
+   * `VisibilityState` — `{ [colId]: boolean }`. Hidden columns drop automatically from header + body. Two-way: funnels a fresh object through `visibility-change`.
+   */
+  columnVisibility?: Record<string, any>;
+  defaultColumnVisibility?: Record<string, any>;
+  onColumnVisibilityChange?: (columnVisibility: Record<string, any>) => void;
+  /**
+   * `ColumnSizingState` — `{ [colId]: number }`. Driven live by the pointer-drag resize handle (`columnResizeMode: 'onChange'`). Two-way: fires `resize-change`.
+   */
+  columnSizing?: Record<string, any>;
+  defaultColumnSizing?: Record<string, any>;
+  onColumnSizingChange?: (columnSizing: Record<string, any>) => void;
+  /**
+   * `ColumnOrderState` — `string[]`. A fresh order array on reorder (never an in-place splice). Two-way: fires `reorder-change`.
+   */
+  columnOrder?: any[];
+  defaultColumnOrder?: any[];
+  onColumnOrderChange?: (columnOrder: any[]) => void;
+  /**
+   * `ColumnPinningState` — `{ left: string[], right: string[] }`. Pinned columns get `position: sticky` + computed offsets. Defaults to `{ left: [], right: [] }`. Two-way: fires `pin-change`.
+   */
+  columnPinning?: Record<string, any>;
+  defaultColumnPinning?: Record<string, any>;
+  onColumnPinningChange?: (columnPinning: Record<string, any>) => void;
+  /**
+   * Pure-CSS sticky header: the `<thead>` sticks to the top of the scroll container.
+   */
+  stickyHeader?: boolean;
+  /**
+   * `'table'` (default, row-oriented, byte-behaviorally identical to a plain accessible table) | `'grid'` (GA since Phase 63) — lights up the full WAI-ARIA **[grid interaction mode](/components/data-table-grid-mode)**: `role="grid"`, a roving single tab-stop, 2-D APG arrow-key cell navigation, range selection, and clipboard support.
+   */
+  interactionMode?: string;
+  /**
+   * Grid mode only. When `true`, a plain click on an **editable** cell opens its editor immediately (single-click-to-edit) instead of just activating the cell. Default `false` keeps click-to-activate (double-click opens the editor). Shift+click (range selection) and clicks on non-editable cells are unaffected.
+   */
+  singleClickEdit?: boolean;
+  /**
+   * Grid mode. When `true`, every committed data mutation (cell/row edit, paste, fill, cut, clear) becomes one undo step: Ctrl/Cmd+Z undoes, Ctrl/Cmd+Y or Ctrl/Cmd+Shift+Z redoes. Default `false` records no history and Ctrl+Z/Y are inert.
+   */
+  undoable?: boolean;
+  /**
+   * The maximum number of undo steps retained (oldest evicted past this depth). Only consulted when `undoable` is `true`.
+   */
+  undoLimit?: number;
+  /**
+   * Opt-in vertical **row windowing**. When `true`, only the visible slice of rows renders inside a bounded `rdt-scroll` container (with leading/trailing spacer rows preserving total scroll height), windowing over the full filtered + sorted (pre-pagination) model and suppressing the client pagination chrome. Default `false` is byte-identical to a non-virtual table.
+   */
+  virtual?: boolean;
+  /**
+   * Estimated row height (px) seeding the windowing engine before `measureElement` refines actual heights. Only consulted when `virtual` is on.
+   */
+  estimateRowHeight?: number;
+  /**
+   * A CSS length string bounding the `rdt-scroll` container when `virtual` is on (e.g. `'400px'`). Mirrored to the `--rozie-data-table-max-height` custom property; the prop wins, the token is the fallback.
+   */
+  maxHeight?: string;
+  onSortChange?: (...args: unknown[]) => void;
+  onExpandChange?: (...args: unknown[]) => void;
+  onGroupChange?: (...args: unknown[]) => void;
+  onFilterChange?: (...args: unknown[]) => void;
+  onPageChange?: (...args: unknown[]) => void;
+  onSelectionChange?: (...args: unknown[]) => void;
+  onVisibilityChange?: (...args: unknown[]) => void;
+  onResizeChange?: (...args: unknown[]) => void;
+  onReorderChange?: (...args: unknown[]) => void;
+  onPinChange?: (...args: unknown[]) => void;
+  onHistoryChange?: (...args: unknown[]) => void;
+  onActivecellChange?: (...args: unknown[]) => void;
+  onRangeChange?: (...args: unknown[]) => void;
+  onCellEditCommit?: (...args: unknown[]) => void;
+  onRowEditCommit?: (...args: unknown[]) => void;
+  children?: JSX.Element;
+  groupBarSlot?: (ctx: GroupBarSlotCtx) => JSX.Element;
+  selectAllSlot?: (ctx: SelectAllSlotCtx) => JSX.Element;
+  colHeaderSlot?: (ctx: ColHeaderSlotCtx) => JSX.Element;
+  filterSlot?: (ctx: FilterSlotCtx) => JSX.Element;
+  selectCellSlot?: (ctx: SelectCellSlotCtx) => JSX.Element;
+  cellSlot?: (ctx: CellSlotCtx) => JSX.Element;
+  editorSlot?: (ctx: EditorSlotCtx) => JSX.Element;
+  detailSlot?: (ctx: DetailSlotCtx) => JSX.Element;
+  slots?: Record<string, (ctx: any) => JSX.Element>;
+  ref?: (h: DataTableHandle) => void;
+}
+interface DataTableHandle {
+  sortColumn: (...args: any[]) => any;
+  clearSorting: (...args: any[]) => any;
+  toggleRowExpanded: (...args: any[]) => any;
+  expandAll: (...args: any[]) => any;
+  collapseAll: (...args: any[]) => any;
+  getExpandedRows: (...args: any[]) => any;
+  applyGrouping: (...args: any[]) => any;
+  clearGrouping: (...args: any[]) => any;
+  getFacetedUniqueValues: (...args: any[]) => any;
+  getFacetedMinMaxValues: (...args: any[]) => any;
+  getColumnDefs: (...args: any[]) => any;
+  toggleAllRows: (...args: any[]) => any;
+  clearSelection: (...args: any[]) => any;
+  getSelectedRows: (...args: any[]) => any;
+  setPage: (...args: any[]) => any;
+  setRowsPerPage: (...args: any[]) => any;
+  toggleColumnVisibility: (...args: any[]) => any;
+  applyColumnOrder: (...args: any[]) => any;
+  resetColumnSizing: (...args: any[]) => any;
+  pinColumn: (...args: any[]) => any;
+  focusCell: (...args: any[]) => any;
+  getActiveCell: (...args: any[]) => any;
+  clearActiveCell: (...args: any[]) => any;
+  getRowIndexRelativeToPage: (...args: any[]) => any;
+  editCell: (...args: any[]) => any;
+  commitEditing: (...args: any[]) => any;
+  editRow: (...args: any[]) => any;
+  getSelectedRange: (...args: any[]) => any;
+  cut: (...args: any[]) => any;
+  undo: (...args: any[]) => any;
+  redo: (...args: any[]) => any;
+  canUndo: (...args: any[]) => any;
+  canRedo: (...args: any[]) => any;
+  clearHistory: (...args: any[]) => any;
+}
+declare function DataTable(_props: DataTableProps): JSX.Element;
+//#endregion
+//#region src/Column.d.ts
+interface ColumnProps {
+  /**
+   * The column id. Optional — defaults to `field` when omitted. Used as the key in the id-keyed registry union and in the `#cell` / `#colHeader` slot dispatch.
+   */
+  id?: string;
+  /**
+   * The row field this column reads (table-core `accessorKey`). The plain accessor value renders when the `#cell` slot falls through.
+   * @example
+   * <Column field="email" header="Email" />
+   */
+  field?: string;
+  /**
+   * The header label, rendered when the parent `#colHeader` slot falls through to the plain label.
+   */
+  header?: string;
+  /**
+   * Whether this column participates in click-to-sort. Default `false`. Bind `:sortable="true"` (a bare attr only coerces on Vue+Lit).
+   */
+  sortable?: boolean;
+  /**
+   * Whether this column participates in per-column filtering (the `#filter` slot / faceted filter chrome). Default `false`.
+   */
+  filterable?: boolean;
+  /**
+   * Pin side: `''` (unpinned) | `'left'` | `'right'`. Reserved metadata carried into the parent's column pinning state.
+   */
+  pinned?: string;
+  /**
+   * Optional fixed/initial column width — a CSS length string or a px number.
+   */
+  width?: string | number;
+  /**
+   * Reserved per-column metadata flagging participation in the expand affordance. The expander chevron is its own auto-injected leading column on `<DataTable expandable>`, so this is forward-compat metadata, not the toggle host. Default `false`.
+   */
+  expandable?: boolean;
+  /**
+   * Whether this column is offered to the headless `#groupBar` as a grouping target. Defaults `true` (opt-OUT via `:groupable="false"`); this only filters the groupable-columns list. Whether grouping is engaged is driven by the parent's `grouping` model, never this flag.
+   */
+  groupable?: boolean;
+  /**
+   * The table-core aggregation for this column inside a group-header cell. Either a built-in name string — `'sum'` | `'min'` | `'max'` | `'extent'` | `'mean'` | `'median'` | `'unique'` | `'uniqueCount'` | `'count'` — or a custom function `(columnId, leafRows, childRows) => any` (defensively wrapped by the parent so a throw cannot crash grouping). Null → no aggregation (the group-header cell renders as a placeholder).
+   */
+  aggregationFn?: (string | ((...args: unknown[]) => unknown)) | null;
+  /**
+   * Whether this column's cells are editable (opt-in). Default `false` → the column is read-only and the display↔editor branch never mounts an editor. Bind `:editable="true"` (a bare attr only coerces on Vue+Lit).
+   */
+  editable?: boolean;
+  /**
+   * Built-in editor type for this column: `'text'` | `'number'` | `'select'` | `'checkbox'`. Ignored when a custom `#editor` scoped slot handles the column. Default `'text'`.
+   */
+  editor?: string;
+  /**
+   * Options for `editor: 'select'` — `[{ value, label }]`. Empty for other editor types.
+   */
+  editorOptions?: any[];
+  /**
+   * Synchronous per-column validator `(value, row) => true | string`. A string return is the error message (the editor stays open and the aria-live region announces it). Null → no validation. The parent wraps it defensively against a thrown/non-bool/non-string return.
+   */
+  validate?: ((...args: unknown[]) => unknown) | null;
+}
+declare function Column(_props: ColumnProps): JSX.Element;
+//#endregion
+//#region src/EditorText.d.ts
+interface EditorTextProps {
+  /**
+   * The column id (mirrors the `#editor` slot scope). Used as the input `aria-label` fallback.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#editor` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The consumer's row data object (opaque passthrough from the `#editor` slot scope).
+   */
+  row?: (unknown) | null;
+  /**
+   * The current cell value the editor seeds its local draft from (setup-once).
+   */
+  value?: (unknown) | null;
+  /**
+   * `(value) => void` — commit the edited cell value (from the `#editor` slot scope). Null-guarded at call sites.
+   */
+  commit?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * `() => void` — revert the edit and close the editor (from the `#editor` slot scope). Null-guarded at call sites.
+   */
+  cancel?: ((...args: unknown[]) => unknown) | null;
+}
+declare function EditorText(_props: EditorTextProps): JSX.Element;
+//#endregion
+//#region src/EditorNumber.d.ts
+interface EditorNumberProps {
+  /**
+   * The column id (mirrors the `#editor` slot scope). Used as the input `aria-label`.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#editor` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The consumer's row data object (opaque passthrough from the `#editor` slot scope).
+   */
+  row?: (unknown) | null;
+  /**
+   * The current cell value the local draft string seeds from (setup-once).
+   */
+  value?: (unknown) | null;
+  /**
+   * `(value) => void` — commit the cell. The draft is coerced with `Number()` at commit time; an empty/whitespace or non-numeric draft commits `null` (never `NaN`). Null-guarded at call sites.
+   */
+  commit?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * `() => void` — revert the edit (Escape). Null-guarded at call sites.
+   */
+  cancel?: ((...args: unknown[]) => unknown) | null;
+}
+declare function EditorNumber(_props: EditorNumberProps): JSX.Element;
+//#endregion
+//#region src/EditorSelect.d.ts
+interface EditorSelectProps {
+  /**
+   * The column id (mirrors the `#editor` slot scope). Used as the select `aria-label`.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#editor` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The consumer's row data object (opaque passthrough from the `#editor` slot scope).
+   */
+  row?: (unknown) | null;
+  /**
+   * The current cell value the local draft seeds from (setup-once); String-coerced for the `<select>` binding.
+   */
+  value?: (unknown) | null;
+  /**
+   * `(value) => void` — commit the cell with the selected value (Enter / blur). Null-guarded at call sites.
+   */
+  commit?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * `() => void` — revert the edit (Escape). Null-guarded at call sites.
+   */
+  cancel?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * The select options — `[{ value, label }]`. Mirrors `<Column editorOptions>`.
+   */
+  options?: any[];
+}
+declare function EditorSelect(_props: EditorSelectProps): JSX.Element;
+//#endregion
+//#region src/EditorCheckbox.d.ts
+interface EditorCheckboxProps {
+  /**
+   * The column id (mirrors the `#editor` slot scope). Used as the input `aria-label`.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#editor` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The consumer's row data object (opaque passthrough from the `#editor` slot scope).
+   */
+  row?: (unknown) | null;
+  /**
+   * The current cell value — coerced to a real boolean via `!!` to seed the checkbox `checked` state.
+   */
+  value?: (unknown) | null;
+  /**
+   * `(value) => void` — commit the cell. This editor immediately commits the boolean checked state on `@change`. Null-guarded at call sites.
+   */
+  commit?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * `() => void` — revert the edit (Escape). Null-guarded at call sites.
+   */
+  cancel?: ((...args: unknown[]) => unknown) | null;
+}
+declare function EditorCheckbox(_props: EditorCheckboxProps): JSX.Element;
+//#endregion
+//#region src/EditorDate.d.ts
+interface EditorDateProps {
+  /**
+   * The column id (mirrors the `#editor` slot scope). Used as the input `aria-label`.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#editor` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The consumer's row data object (opaque passthrough from the `#editor` slot scope).
+   */
+  row?: (unknown) | null;
+  /**
+   * The current cell value the local draft seeds from (setup-once); String-coerced to an ISO `YYYY-MM-DD` string for the native date input.
+   */
+  value?: (unknown) | null;
+  /**
+   * `(value) => void` — commit the cell with the ISO `YYYY-MM-DD` string (Enter / blur). Null-guarded at call sites.
+   */
+  commit?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * `() => void` — revert the edit (Escape). Null-guarded at call sites.
+   */
+  cancel?: ((...args: unknown[]) => unknown) | null;
+}
+declare function EditorDate(_props: EditorDateProps): JSX.Element;
+//#endregion
+//#region src/FilterText.d.ts
+interface FilterTextProps {
+  /**
+   * The column id (mirrors the `#filter` slot scope) — used as the filter key and the input `aria-label`.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#filter` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The current column filter value the local draft seeds from (setup-once).
+   */
+  value?: (unknown) | null;
+  /**
+   * `(columnId, value) => void` — apply the column filter (Enter / blur applies, Escape clears). Null-guarded at call sites.
+   */
+  setFilter?: ((...args: unknown[]) => unknown) | null;
+}
+declare function FilterText(_props: FilterTextProps): JSX.Element;
+//#endregion
+//#region src/FilterNumberRange.d.ts
+interface FilterNumberRangeProps {
+  /**
+   * The column id (mirrors the `#filter` slot scope) — used as the filter key and the input `aria-label` base.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#filter` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The current column filter value (`[min, max]` tuple or null) the two inputs seed from (setup-once).
+   */
+  value?: (unknown) | null;
+  /**
+   * `(columnId, value) => void` — apply the column filter as a `[min, max]` tuple (each side coerced to a Number or `undefined`, so a one-sided range works); both empty clears the filter. Null-guarded at call sites.
+   */
+  setFilter?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * The faceted `[min, max]` bounds for this column (`[number, number]` or null) — drives the input placeholders only.
+   */
+  minMax?: (unknown) | null;
+}
+declare function FilterNumberRange(_props: FilterNumberRangeProps): JSX.Element;
+//#endregion
+//#region src/FilterSelect.d.ts
+interface FilterSelectProps {
+  /**
+   * The column id (mirrors the `#filter` slot scope) — used as the filter key and the select `aria-label`.
+   */
+  columnId?: string;
+  /**
+   * The table-core column object (opaque passthrough from the `#filter` slot scope).
+   */
+  column?: (unknown) | null;
+  /**
+   * The current column filter value the select seeds from (String-coerced).
+   */
+  value?: (unknown) | null;
+  /**
+   * `(columnId, value) => void` — apply the column filter on change; the leading empty "All" option clears it. Null-guarded at call sites.
+   */
+  setFilter?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * The faceted distinct keys for this column (cross-filtered, keys only — no occurrence counts) used to build the `<option>` list.
+   */
+  uniqueValues?: any[];
+}
+declare function FilterSelect(_props: FilterSelectProps): JSX.Element;
+//#endregion
+//#region src/GroupBar.d.ts
+interface GroupBarProps {
+  /**
+   * The ordered active grouping key array (read-only source of truth from the `#groupBar` slot scope). This drop-in never keeps its own copy — it always reads this and writes through `applyGrouping` / `clearGrouping`.
+   */
+  grouping?: any[];
+  /**
+   * The columns offered as grouping targets — `[{ id, label }]` — rendered as draggable chips.
+   */
+  groupableColumns?: any[];
+  /**
+   * `(cols: string[]) => void` — the only add/reorder writer for the grouping order. Null-guarded at call sites.
+   */
+  applyGrouping?: ((...args: unknown[]) => unknown) | null;
+  /**
+   * `() => void` — the only clear writer; resets grouping to empty. Null-guarded at call sites.
+   */
+  clearGrouping?: ((...args: unknown[]) => unknown) | null;
+}
+declare function GroupBar(_props: GroupBarProps): JSX.Element;
+//#endregion
+//#region src/DetailPanel.d.ts
+interface DetailPanelProps {
+  /**
+   * The raw row object (the `#detail` slot scope `row` = `row.original`). This drop-in walks its own enumerable keys and String-coerces each value into a key/value definition list; a null row renders an empty list.
+   */
+  row?: (unknown) | null;
+}
+declare function DetailPanel(_props: DetailPanelProps): JSX.Element;
+//#endregion
+export { Column, DataTable, DataTable as default, type DataTableHandle, DetailPanel, EditorCheckbox, EditorDate, EditorNumber, EditorSelect, EditorText, FilterNumberRange, FilterSelect, FilterText, GroupBar };