@nsaa/data-table 0.0.0-stage → 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1221 @@
+
+import { Cell, Column, ColumnFiltersState, Header, ReactTable, Row, RowData, SortingState, Table, TableFeatures } from "@tanstack/react-table";
+import { CSSProperties, HTMLAttributes, JSX, ReactElement, ReactNode, Ref, RefObject } from "react";
+import { ScrollArea } from "@base-ui/react/scroll-area";
+import { CollisionDetection, DndContextProps, DragCancelEvent, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, Modifier, UniqueIdentifier } from "@dnd-kit/core";
+import { SortingStrategy } from "@dnd-kit/sortable";
+import { VirtualizerOptions } from "@tanstack/react-virtual";
+export interface DataGridI18nLabels {
+  sortAscending: string;
+  sortDescending: string;
+  pinColumnStart: string;
+  pinColumnEnd: string;
+  moveColumnStart: string;
+  moveColumnEnd: string;
+  columnsMenu: string;
+  unpinColumn: (title: string) => string;
+  toggleColumns: string;
+  rowCreate: string;
+  pinRow: string;
+  unpinRow: string;
+  selectRow: string;
+  selectAll: string;
+  expandRow: string;
+  collapseRow: string;
+  dragToReorder: string;
+  dragToReorderRow: string;
+  reorderingUnavailable: string;
+  loading: string;
+  empty: string;
+  allRowsLoaded: string;
+  rowsPerPage: string;
+  paginationInfo: (info: {
+    from: number;
+    to: number;
+    count: number;
+  }) => string;
+  previousPage: string;
+  nextPage: string;
+  goToPage: (page: number) => string;
+  paginationEllipsis: string;
+  filterSelectedCount: (count: number) => string;
+  filterNoResults: string;
+  filterClear: string;
+}
+export interface DataGridI18nConfig {
+  labels: DataGridI18nLabels;
+}
+export type DataGridI18nOverrides = {
+  labels?: Partial<DataGridI18nLabels>;
+};
+/**
+ * A shallow merge per section, deliberately: a deep merge would leak a
+ * default back into a function-valued label the consumer replaced. With no
+ * overrides the frozen default is returned as-is, so the merge is free to
+ * run on every render without producing a new identity.
+ */
+export declare function mergeDataGridI18n(overrides?: DataGridI18nOverrides): DataGridI18nConfig;
+/**
+ * Per-column extras the grid reads off `columnDef.meta`.
+ *
+ * TanStack v9 resolves this through the `columnMeta` slot on the feature
+ * bundle below instead of a global `declare module` augmentation, so
+ * installing the data grid no longer widens `ColumnMeta` for every other
+ * table in the consuming app.
+ */
+/**
+ * Per-column write contract for the spreadsheet operations (paste, fill,
+ * clear, cut). Presence marks the column writable; every write still flows
+ * through `onCellsChange`, so the consumer's state stays the only data owner.
+ */
+export interface DataGridColumnCellEdit<TData> {
+  /**
+   * Set false for a column that formats clipboard output but is never
+   * written; a function decides per row, so locked rows (archived, another
+   * user's, a totals row) reject like any read-only cell. Defaults to true.
+   */
+  editable?: boolean | ((row: TData) => boolean);
+  /**
+   * Clipboard or fill string to typed value. Return undefined to reject the
+   * cell into `rejected`. Without it the raw string passes through unchanged -
+   * a deliberate non-coercion, so a number column receives strings only when
+   * the consumer chose not to parse.
+   */
+  parse?: (raw: string, row: TData) => unknown;
+  /** Typed value to clipboard string. Fallback: String(value ?? ""). */
+  format?: (value: unknown, row: TData) => string;
+  /** Value dispatched by Delete/Backspace and cut. Defaults to null. */
+  clearValue?: unknown;
+  /**
+   * Opt into the grid's built-in free-text editor: an overlay input (or
+   * auto-growing textarea) flush over the focused cell, opened by Enter, F2,
+   * typing, or double-click, committing through `onCellsChange` as source
+   * `"edit"` with `parse` applied. Columns without it stay consumer-edited
+   * via `onCellEditRequest` or their own cell renderers.
+   */
+  control?: "text" | "textarea";
+}
+export interface DataGridColumnMeta<TData> {
+  headerTitle?: string;
+  headerClassName?: string;
+  cellClassName?: string;
+  skeleton?: ReactNode;
+  expandedContent?: (row: TData) => ReactNode;
+  autoSize?: boolean;
+  /** Header spans this many leaves: this one and its next adjacent siblings. */
+  headerColSpan?: number;
+  cellEdit?: DataGridColumnCellEdit<TData>;
+  /**
+   * Under `columnsResizable`, this column absorbs the free space the filler
+   * strip would otherwise hold, so the grid always reads full-width and the
+   * built-in editor covers the whole cell. One column per grid; while free
+   * space remains, manual resizing of this column is visually a no-op (the
+   * absorbed space compensates), the flex-column trade-off.
+   */
+  fillWidth?: boolean;
+}
+/**
+ * The batteries-included feature bundle every ReUI data-grid example builds
+ * on. v9 requires each table to declare its features up front, and the grid's
+ * render path needs the ones registered here: `columnVisibilityFeature` alone
+ * gates `row.getVisibleCells()`, so even a grid that never hides a column
+ * needs it to render at all.
+ *
+ * Pass it straight through for the full grid:
+ *
+ * ```tsx
+ * const table = useTable({ features: dataGridFeatures, columns, data })
+ * ```
+ *
+ * Extend it when a grid needs more, keeping each prerequisite feature ahead of
+ * the slot that depends on it:
+ *
+ * ```tsx
+ * const features = tableFeatures({
+ *   ...dataGridFeatures,
+ *   columnGroupingFeature,
+ *   groupedRowModel: createGroupedRowModel(),
+ * })
+ * ```
+ *
+ * Or drop it entirely and hand `<DataGrid>` a leaner table - the components
+ * accept any bundle, so you keep full ownership of the TanStack core.
+ */
+export declare const dataGridFeatures: {
+  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+  columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+  columnPinningFeature: import("@tanstack/react-table").TableFeature;
+  columnSizingFeature: import("@tanstack/react-table").TableFeature;
+  columnResizingFeature: import("@tanstack/react-table").TableFeature;
+  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+  rowSortingFeature: import("@tanstack/react-table").TableFeature;
+  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+  rowPinningFeature: import("@tanstack/react-table").TableFeature;
+  cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+  sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  paginatedRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  expandedRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedRowModel: (table: Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedUniqueValues: (table: Table<TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  sortFns: {
+    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+  };
+  columnMeta: DataGridColumnMeta<any>;
+};
+/** The feature set `dataGridFeatures` registers. */
+export type DataGridFeatures = typeof dataGridFeatures;
+/**
+ * The grid's internal view of the table.
+ *
+ * `TFeatures` is invariant in v9 and an unresolved generic one collapses to a
+ * union that includes the bare core arm, so no generic signature can call
+ * `getVisibleCells()`, `getStartVisibleLeafColumns()` and friends. The public
+ * components stay generic so consumers can pass any bundle they like; the
+ * table is widened to this concrete type exactly once, on the way into
+ * context, and every internal component reads it from there.
+ */
+export type DataGridTableInstance<TData extends object> = ReactTable<DataGridFeatures, TData>;
+/** Label for headers / column visibility: `meta.headerTitle`, string `columnDef.header`, or `column.id`. */
+export declare function getColumnHeaderLabel<TData extends RowData, TValue>(column: Column<DataGridFeatures, TData, TValue>): string;
+/**
+ * meta.headerColSpan: the sibling leaves each owning leaf's header covers,
+ * by owner id. Each must render right after the last in its pin family, or
+ * the span ends there; the header rows, the resize indicator and the move
+ * and drop targets all read spans from here.
+ */
+export declare function getDataGridHeaderSpans<TData extends object>(table: DataGridTableInstance<TData>): Map<string, Column<{
+  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+  columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+  columnPinningFeature: import("@tanstack/react-table").TableFeature;
+  columnSizingFeature: import("@tanstack/react-table").TableFeature;
+  columnResizingFeature: import("@tanstack/react-table").TableFeature;
+  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+  rowSortingFeature: import("@tanstack/react-table").TableFeature;
+  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+  rowPinningFeature: import("@tanstack/react-table").TableFeature;
+  cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+  sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  paginatedRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  expandedRowModel: (table: Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedRowModel: (table: Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedUniqueValues: (table: Table<TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  sortFns: {
+    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+  };
+  columnMeta: DataGridColumnMeta<any>;
+}, TData, unknown>[]>;
+/**
+ * The td contract for spreadsheet selection. Call inside a
+ * `Subscribe source={table.atoms.cellSelection}` render only: the reads are
+ * builder calls whose state dependency React Compiler cannot see, exactly the
+ * trap the row-selection checkbox documents.
+ */
+export declare function getDataGridCellSelectionCellAttrs<TData extends object>(cell: Cell<DataGridFeatures, TData, unknown>): {
+  "aria-selected": boolean;
+  "data-col-id": string;
+  "data-cell-selected": true | undefined;
+  "data-cell-focused": true | undefined;
+  "data-cell-edge-top": true | undefined;
+  "data-cell-edge-right": true | undefined;
+  "data-cell-edge-bottom": true | undefined;
+  "data-cell-edge-left": true | undefined;
+};
+/**
+ * Selection chrome for a body td, activated by the data attributes above plus
+ * the imperatively toggled `data-cell-fill-target` (fill-drag preview, written
+ * outside React like the resize indicator). A ::before overlay, not outline
+ * or box-shadow: an outline ring hugs the cell box and cannot line up with
+ * the gridlines the perimeter paints on, and the pinned-column dividers
+ * already own the cell's shadow slot (tailwind-merge would collapse a second
+ * shadow-[...] into it).
+ */
+export declare const dataGridCellSelectionCellClasses: string;
+export type DataGridApiFetchParams = {
+  pageIndex: number;
+  pageSize: number;
+  sorting?: SortingState;
+  filters?: ColumnFiltersState;
+  searchQuery?: string;
+};
+export type DataGridApiResponse<T> = {
+  data: T[];
+  empty: boolean;
+  pagination: {
+    total: number;
+    page: number;
+  };
+};
+/**
+ * Everything `<DataGrid>` accepts except the two props the provider consumes
+ * itself. Kept feature-agnostic: layout and messaging never depend on which
+ * TanStack features the consumer registered.
+ */
+export type DataGridLayoutProps<TData extends object> = Omit<DataGridProps<TableFeatures, TData>, "table" | "children">;
+export interface DataGridContextProps<TData extends object> {
+  props: DataGridLayoutProps<TData>;
+  table: DataGridTableInstance<TData>;
+  recordCount: number;
+  isLoading: boolean;
+  /** Stable per-grid prefix for the DOM ids ARIA relations point at. */
+  gridId: string;
+  /** The merged label set; components read `i18n.labels.<key>`. */
+  i18n: DataGridI18nConfig;
+  /**
+   * Internal coordinator for `meta.autoSize` columns. Lives at the core level
+   * so every table variant and viewport instance shares one application state.
+   */
+  autoSize?: DataGridAutoSizeController;
+}
+/**
+ * Row and column ids are consumer strings; DOM ids cannot carry spaces or
+ * quotes. One shared sanitizer so `aria-activedescendant` writers and the id
+ * renderers always agree on the same encoding.
+ */
+export declare function toDataGridDomId(value: string): string;
+export type DataGridAutoSizeController = {
+  /**
+   * Feeds the controller one viewport measurement: the SIGNED free space
+   * between the scroll container and the table, negative while the table
+   * overflows. The first sight of a `meta.autoSize` column absorbs the
+   * free space into its width; after that, every measurement REFLOWS the
+   * same growth - a wider window widens the column, a narrower one gives
+   * the space back down to the column's `minSize` (or its starting width
+   * when none is set) - so the grid tracks its container live. Commits
+   * are coalesced for performance: sub-pixel deltas are dropped, a
+   * streaming resize gets one leading commit plus one trailing commit at
+   * settle, and a width the user dragged is never touched. Safe to call
+   * from every viewport measurement; returns true when a sizing update
+   * was dispatched.
+   */
+  apply: (freeSpace: number) => boolean;
+  /**
+   * The width the armed column would reflow to at this free space, and the
+   * width it holds now, without committing anything. Null when no column is
+   * armed. A live (onChange) resize previews with it on every move.
+   */
+  preview: (freeSpace: number) => {
+    columnId: string;
+    current: number;
+    size: number;
+  } | null;
+  /**
+   * Records a width the caller commits for the armed column, so the next
+   * measurement reads it as this coordinator's own write and keeps
+   * reflowing, rather than as a user drag that stands it down.
+   */
+  adopt: (columnId: string, size: number) => void;
+};
+export type DataGridRequestParams = {
+  pageIndex: number;
+  pageSize: number;
+  sorting?: SortingState;
+  columnFilters?: ColumnFiltersState;
+};
+/** Which spreadsheet operation produced a cell change batch. */
+export type DataGridCellsChangeSource = "paste" | "cut" | "clear" | "fill" | "edit";
+export interface DataGridCellChange<TData> {
+  rowId: string;
+  columnId: string;
+  /** The consumer's row object, so immutable write-back needs no second lookup. */
+  row: TData;
+  /** Accessor value at dispatch time; enables consumer-side undo stacks. */
+  previousValue: unknown;
+  /** Typed value produced by `meta.cellEdit.parse`, or `clearValue` for clear/cut. */
+  value: unknown;
+}
+/** What onCellsCopy receives after the grid writes the clipboard. */
+export interface DataGridCopyDetails {
+  /** The TSV text that reached the clipboard. */
+  text: string;
+  /** The same content as a row-major grid of formatted fields. */
+  grid: string[][];
+  /** True when the write came from a cut, which clears the region next. */
+  cut: boolean;
+}
+/** One resolved positive region, in pre-paginated display indexes. */
+export interface DataGridCellSelectionBound {
+  minRowIndex: number;
+  maxRowIndex: number;
+  minColumnIndex: number;
+  maxColumnIndex: number;
+}
+/** What onCellSelectionChange receives, resolved from the live selection. */
+export interface DataGridCellSelectionSnapshot {
+  /** The virtually focused cell, the active range's anchor. Null when clear. */
+  focused: {
+    rowId: string;
+    columnId: string;
+  } | null;
+  /** Every positive region, geometric order. */
+  bounds: DataGridCellSelectionBound[];
+  /** The most recent region, the one copy and paste act on. */
+  activeBound: DataGridCellSelectionBound | null;
+  /**
+   * Cells of the selection the view can show - the count that matches the
+   * painted range and what a batch will touch.
+   */
+  visibleCellCount: number;
+}
+export interface DataGridCellRejection {
+  rowId: string;
+  columnId: string;
+  raw: string;
+  reason: "readonly" | "invalid";
+}
+/**
+ * Lifecycle of a row for the optional CRUD indications: "new" and "dirty"
+ * tint the row, "deleted" mutes and strikes it. Purely presentational - the
+ * consumer's state stays the only owner of what the statuses mean.
+ */
+export type DataGridRowStatus = "new" | "dirty" | "deleted";
+/**
+ * Lifecycle of a cell for the optional CRUD indications: a corner mark in
+ * the amber tone for "dirty", the destructive tone for "invalid".
+ */
+export type DataGridCellStatus = "dirty" | "invalid";
+/**
+ * Asks the consumer to open its editor for the focused cell: Enter or F2, or
+ * a typed printable character (then `initialText` carries it, the
+ * Notion/Airtable type-to-replace flow). Dispatched only for cells whose
+ * column is writable via `meta.cellEdit`.
+ */
+export interface DataGridCellEditRequest<TData> {
+  rowId: string;
+  columnId: string;
+  row: TData;
+  previousValue: unknown;
+  /** The typed character that started the edit; absent for Enter and F2. */
+  initialText?: string;
+}
+/**
+ * One batch per operation, however many cells it spans: a 10k-cell paste is
+ * one callback, one consumer setState, one table rebuild. The grid never
+ * writes data itself.
+ */
+export interface DataGridCellsChangeDetails<TData> {
+  source: DataGridCellsChangeSource;
+  changes: DataGridCellChange<TData>[];
+  rejected: DataGridCellRejection[];
+}
+export interface DataGridProps<TFeatures extends TableFeatures, TData extends object> {
+  className?: string;
+  table?: Table<TFeatures, TData>;
+  recordCount: number;
+  children?: ReactNode;
+  onRowClick?: (row: TData) => void;
+  /**
+   * Receives every spreadsheet write batch (paste, cut, clear, fill, edit).
+   * Served through the props getter like `onRowClick`, so an inline identity
+   * never republishes the context. Absent: copy still works, writes no-op.
+   */
+  onCellsChange?: (details: DataGridCellsChangeDetails<TData>) => void;
+  /**
+   * Opens the consumer's editor from the keyboard: Enter, F2, or typing on
+   * the focused cell. Absent: Enter keeps moving down, typing does nothing.
+   */
+  onCellEditRequest?: (request: DataGridCellEditRequest<TData>) => void;
+  /**
+   * Fires on every cell-selection change (focus moves, ranges grow or
+   * clear) with a resolved snapshot, so a selection count, formula bar or
+   * context panel needs no reach into TanStack internals.
+   */
+  onCellSelectionChange?: (snapshot: DataGridCellSelectionSnapshot) => void;
+  /**
+   * Fires after the grid writes the clipboard (Cmd/Ctrl+C or X, or the
+   * native copy and cut events), e.g. to confirm with a toast.
+   */
+  onCellsCopy?: (details: DataGridCopyDetails) => void;
+  /**
+   * Renders an "Add row" affordance as the table body's last row; clicking
+   * it is the consumer's cue to start creating a row. Absent: no row.
+   */
+  onRowCreate?: () => void;
+  /** Label of the onRowCreate affordance. Defaults to "Add row". */
+  rowCreateLabel?: ReactNode;
+  /**
+   * Rendered inside the table body after the data rows: the slot a DRAFT
+   * row lives in while it is being created, before it joins `data` and the
+   * pagination math. Supply a `<tr>` of cells; the colgroup sizes them.
+   */
+  appendRow?: ReactNode;
+  /**
+   * Optional CRUD indication per row. Return undefined for no indication;
+   * omit the prop entirely to render none anywhere.
+   */
+  getRowStatus?: (row: TData) => DataGridRowStatus | undefined;
+  /**
+   * Optional CRUD indication per cell: the classic corner mark on cells the
+   * consumer tracks as edited or invalid.
+   */
+  getCellStatus?: (row: TData, columnId: string) => DataGridCellStatus | undefined;
+  isLoading?: boolean;
+  /**
+   * Overrides for every built-in string: menu items, aria labels,
+   * pagination copy, state messages. Merged over the defaults; a more
+   * specific component prop (`rowCreateLabel`, `loadingMessage`, the
+   * pagination label props) still wins over its `i18n` counterpart.
+   */
+  i18n?: DataGridI18nOverrides;
+  loadingMode?: "skeleton" | "spinner";
+  loadingMessage?: ReactNode | string;
+  fetchingMoreMessage?: ReactNode | string;
+  allRowsLoadedMessage?: ReactNode | string;
+  emptyMessage?: ReactNode | string;
+  tableLayout?: {
+    dense?: boolean;
+    cellBorder?: boolean;
+    rowBorder?: boolean;
+    rowRounded?: boolean;
+    stripped?: boolean;
+    headerBackground?: boolean;
+    footerBackground?: boolean;
+    headerBorder?: boolean;
+    headerSticky?: boolean;
+    width?: "auto" | "fixed";
+    columnsVisibility?: boolean;
+    columnsResizable?: boolean;
+    columnsResizeMode?: "onChange" | "onEnd";
+    columnsPinnable?: boolean;
+    columnsMovable?: boolean;
+    columnsDraggable?: boolean;
+    rowsDraggable?: boolean;
+    rowsPinnable?: boolean;
+    /** Spreadsheet cell range selection: mouse ranges, keyboard, clipboard chrome. */
+    cellSelection?: boolean;
+    /**
+     * "range" (default): drag, Shift and Ctrl/Cmd gestures and Shift+keys
+     * grow multi-cell regions. "single": one focused cell only - every
+     * gesture collapses to it and Ctrl/Cmd+A is inert.
+     */
+    cellSelectionMode?: "single" | "range";
+    /** Drag-to-fill handle on the selection corner. Requires cellSelection. */
+    cellFillHandle?: boolean;
+    /**
+     * How a cell opens its editor from the mouse: "dblclick" (default,
+     * the spreadsheet standard - first click focuses, second edits) or
+     * "click", opening the editor as soon as a plain click lands on the
+     * focused cell; modifier clicks and drags still select.
+     */
+    cellEditMode?: "dblclick" | "click";
+    /**
+     * When true, committing an edit with Enter moves focus down (Shift+Enter
+     * up), the Sheets and Excel convention. Off by default: the commit keeps
+     * focus on the edited cell. Tab always commits and moves across.
+     */
+    cellEditEnterAdvance?: boolean;
+    /**
+     * The handle's look: "dot" is a solid primary dot kept inside the
+     * cell corner; "ring" is the Sheets-style hollow circle riding the
+     * corner point, clamped at the grid's own boundary; "square" is the
+     * Excel-style solid square inside the corner. Default "dot".
+     */
+    cellFillHandleVariant?: "dot" | "ring" | "square";
+  };
+  tableClassNames?: {
+    base?: string;
+    header?: string;
+    headerRow?: string;
+    headerSticky?: string;
+    body?: string;
+    bodyRow?: string;
+    footer?: string;
+    edgeCell?: string;
+    /** Override the getRowStatus tints; defaults are the warning-muted set. */
+    rowNew?: string;
+    rowDirty?: string;
+    rowDeleted?: string;
+    /**
+     * Override the pinned-row chrome (muted tint, boundary shadow). A grid
+     * that pins a draft row for quick-create wants it to read as an active
+     * row, not a muted one.
+     */
+    rowPinned?: string;
+    /** The onRowCreate affordance row, e.g. to match the grid's row height. */
+    rowCreate?: string;
+    /** The fill handle, e.g. to restyle or resize it beyond the built-in variants. */
+    cellFillHandle?: string;
+  };
+}
+/**
+ * Reads the grid context. Pass `TData` from the calling component when the
+ * table, a row or a cell is handed on to something typed against that row
+ * shape: v9 declares `TData` invariant, so the default `any` no longer
+ * unifies with a concrete row type the way it did on v8.
+ */
+declare function useDataGrid<TData extends object = any>(): DataGridContextProps<TData>;
+type DataGridStateAtom<TValue> = {
+  get: () => TValue;
+  subscribe: (listener: () => void) => {
+    unsubscribe: () => void;
+  };
+};
+/**
+ * Re-renders the caller when one table state atom changes, without waiting
+ * for a render from above. The context holds still while a column resize is
+ * in flight (see DataGridProvider), and React Compiler caches a consumer's
+ * `<DataGridTable />` element, so whatever a drag must keep live (the width
+ * variables, the resize line and indicator) subscribes here. `select` must
+ * return the slice itself or a primitive, or every write re-renders.
+ */
+declare function useDataGridAtom<TValue, TSelected = TValue | undefined>(atom: DataGridStateAtom<TValue> | undefined, select?: (value: TValue | undefined) => TSelected): TSelected;
+declare function DataGridProvider<TData extends object>({ children, table, ...props }: DataGridLayoutProps<TData> & {
+  table: DataGridTableInstance<TData>;
+  children?: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGrid<TFeatures extends TableFeatures, TData extends object>({ children, table, ...props }: DataGridProps<TFeatures, TData>): import("react").JSX.Element;
+declare function DataGridContainer({ children, className }: {
+  children: ReactNode;
+  className?: string;
+  /** Accepted for backwards compatibility; currently has no effect. */
+  border?: boolean;
+}): import("react").JSX.Element;
+interface DataGridFocusCellOptions {
+  /** Also open the cell's editor, the way Enter would. */
+  edit?: boolean;
+}
+/** Imperative surface of the cell-selection controller. */
+interface DataGridCellSelectionApi {
+  /**
+   * Moves the grid's cell focus AND the document focus together, retrying
+   * briefly while the row mounts, so a freshly created row is typeable
+   * without an extra click. `edit: true` also opens the cell's editor the
+   * way Enter would. Registered once the controller is wired; null while
+   * cell selection is off.
+   */
+  focusCell: (rowId: string, columnId: string, options?: DataGridFocusCellOptions) => void;
+  /** Clears every range and the focused cell. */
+  clearSelection: () => void;
+  /** Scrolls a rendered cell into view without moving focus. */
+  scrollToCell: (rowId: string, columnId: string) => void;
+}
+/** Row-major grid to TSV, CRLF rows, Excel-style quoting. */
+declare function serializeDataGridClipboardText(grid: string[][]): string;
+/**
+ * TSV to a row-major grid. A stateful scan, not a split: a quoted field may
+ * contain tabs, quotes and both newline flavors, which is exactly what Excel
+ * emits for a multi-line cell.
+ */
+declare function parseDataGridClipboardText(text: string): string[][];
+/** Repeats a block cyclically to fill rowCount x columnCount. */
+declare function tileDataGridClipboardBlock(block: string[][], rowCount: number, columnCount: number): string[][];
+/**
+ * Cells of the current selection the view can actually show, under the
+ * same row filter the batch builders use, so a count shown next to the
+ * selection always matches what is painted and what a batch will touch.
+ * The feature's own getSelectedCellCount spans off-page rows instead.
+ */
+declare function getDataGridVisibleSelectedCellCount<TData extends object>(table: DataGridTableInstance<TData>,
+/** The grid's body viewport; null falls back to the full-range count. */
+viewport: HTMLElement | null): number;
+/**
+ * The active region as formatted strings, row-major. Columns opted out of
+ * selection are compacted away, matching the feature's own ranges-data
+ * behavior, and rows the view cannot show are skipped when a viewport is
+ * given. Null when nothing is selected.
+ */
+declare function getDataGridActiveRegionGrid<TData extends object>(table: DataGridTableInstance<TData>, viewport?: HTMLElement | null): string[][] | null;
+/**
+ * A clear/cut batch over the selection's writable cells. Non-writable columns
+ * are skipped silently: clearing is an intent over what the grid owns, and a
+ * rejection per read-only cell would be noise. Null when nothing clears.
+ */
+declare function buildDataGridClearDetails<TData extends object>(table: DataGridTableInstance<TData>, source: "clear" | "cut", activeRegionOnly: boolean, viewport?: HTMLElement | null): DataGridCellsChangeDetails<TData> | null;
+type DataGridPasteTarget = {
+  /** Display indexes of the pasted region's first and last row. */
+  startRowIndex: number;
+  endRowIndex: number;
+  /** How many rows a paste actually wrote (hidden rows are skipped). */
+  rowCount?: number;
+  /** Display indexes of the pasted region's first and last column. */
+  startColumnIndex: number;
+  endColumnIndex: number;
+};
+/**
+ * Resolves a parsed clipboard block into a paste batch, Excel semantics:
+ * a 1x1 block fills the whole selected region; a block tiles when the region
+ * is an exact multiple of it; otherwise it pastes once from the region's
+ * top-left, clamped at the grid edges (rows are never grown).
+ */
+declare function buildDataGridPasteDetails<TData extends object>(table: DataGridTableInstance<TData>, block: string[][], viewport?: HTMLElement | null): {
+  details: DataGridCellsChangeDetails<TData>;
+  target: DataGridPasteTarget;
+} | null;
+/**
+ * The inverse batch: every change's value and previousValue swapped and
+ * rejections dropped. Feed it through the same state update onCellsChange
+ * uses to implement undo; inverting the inverse is redo.
+ */
+declare function invertDataGridCellsChange<TData extends object>(details: DataGridCellsChangeDetails<TData>): DataGridCellsChangeDetails<TData>;
+/**
+ * Headless spreadsheet controller: keyboard navigation, clipboard, clear and
+ * the fill-handle drag. Mount once inside `<DataGrid>`, next to the table.
+ * Renders only a hidden anchor; the real listeners attach to the grid's own
+ * body viewport, which also receives focus (container-focus model), so a
+ * virtualized row unmounting can never strand `document.activeElement`.
+ */
+declare function DataGridCellSelection<TData extends object>({ apiRef, clipboard, keyboard }: {
+  /** Receives the controller's imperative API, e.g. for create-row flows. */
+  apiRef?: RefObject<DataGridCellSelectionApi | null>;
+  /** Native copy, cut and paste handling. Defaults to true. */
+  clipboard?: boolean;
+  /**
+   * Arrows (with Ctrl/Cmd edge jumps), Home/End, PageUp/PageDown, Enter,
+   * F2, type-to-edit, Tab, Ctrl/Cmd+A, Delete, Escape. Defaults to true.
+   */
+  keyboard?: boolean;
+}): import("react").JSX.Element;
+/**
+ * Thin shell over row selection for bulk actions: selected count, a slot for
+ * the consumer's controls, and a clear action. Hidden while nothing is
+ * selected. What the controls do stays consumer-owned.
+ *
+ * Presented as a floating toolbar, the Google Sheets way: auto width,
+ * centered, elevated, and sticky to the viewport bottom with breathing room,
+ * so bulk actions stay reachable while the grid scrolls.
+ */
+declare function DataGridSelectionBar({ children, className, label, clearLabel, onClear }: {
+  children?: ReactNode;
+  className?: string;
+  label?: (count: number) => ReactNode;
+  clearLabel?: ReactNode;
+  onClear?: () => void;
+}): import("react").JSX.Element | null;
+interface DataGridColumnFilterProps<TData extends object, TValue> {
+  column?: Column<DataGridFeatures, TData, TValue>;
+  title?: string;
+  options: {
+    label: string;
+    value: string;
+    icon?: React.ComponentType<{
+      className?: string;
+    }>;
+  }[];
+}
+declare function DataGridColumnFilter<TData extends object, TValue>({ column, title, options }: DataGridColumnFilterProps<TData, TValue>): import("react").JSX.Element;
+interface DataGridColumnHeaderProps<TData extends object, TValue> extends HTMLAttributes<HTMLDivElement> {
+  column: Column<DataGridFeatures, TData, TValue>;
+  /** When omitted, uses `column.columnDef.meta.headerTitle`, then a string `columnDef.header`, then `column.id`. */
+  title?: string;
+  icon?: ReactNode;
+  /** Reserved; pin controls are gated by tableLayout.columnsPinnable + column.getCanPin(). */
+  pinnable?: boolean;
+  filter?: ReactNode;
+  visibility?: boolean;
+}
+/**
+ * Sort and pin state reaches this header through builder calls on `column`
+ * (`getIsSorted()`, `getIsPinned()`), and `column` keeps its identity across
+ * renders, so anything memoized against it (the `memo` below, or a consumer's
+ * compiled header template) never re-runs those reads: frozen sort arrows and
+ * pin controls. The `Subscribe` below turns the slices this header actually
+ * reads into a real reactive dependency, and threading the selection through
+ * as a prop is what lets it past the `memo`.
+ */
+declare function DataGridColumnHeader<TData extends object, TValue>(props: DataGridColumnHeaderProps<TData, TValue>): import("react").JSX.Element;
+declare function DataGridColumnVisibility<TData extends object>({ table, trigger }: {
+  table: Table<DataGridFeatures, TData>;
+  trigger: ReactElement<Record<string, unknown>>;
+}): import("react").JSX.Element;
+interface DataGridPaginationProps {
+  sizes?: number[];
+  sizesInfo?: string;
+  sizesLabel?: string;
+  sizesDescription?: string;
+  sizesSkeleton?: ReactNode;
+  more?: boolean;
+  /** Page buttons the truncated middle shows; the row adds first, last and
+   *  an ellipsis for each hidden stretch. Clamped to a minimum of 3. */
+  moreLimit?: number;
+  info?: string;
+  infoSkeleton?: ReactNode;
+  className?: string;
+  rowsPerPageLabel?: string;
+  previousPageLabel?: string;
+  nextPageLabel?: string;
+  ellipsisText?: string;
+}
+declare function DataGridPagination(props: DataGridPaginationProps): JSX.Element;
+type DataGridScrollAreaOrientation = "horizontal" | "vertical" | "both";
+type DataGridScrollAreaProps = Omit<ScrollArea.Root.Props, "children"> & {
+  children: ReactNode;
+  orientation?: DataGridScrollAreaOrientation;
+};
+declare function DataGridScrollArea({ children, className, orientation, ...props }: DataGridScrollAreaProps): import("react").JSX.Element;
+declare function getPinningStyles<TData extends object>(column: Column<DataGridFeatures, TData, unknown>): CSSProperties;
+declare function getDataGridTreeIndentStyle<TData extends object>(row: Row<DataGridFeatures, TData>, indent?: number): CSSProperties;
+/**
+ * Nearest scroll-area viewport that belongs to THIS grid. A viewport outside
+ * the grid's own container (e.g. a page-level ScrollArea) would make the
+ * width measurement - and the virtualizer - bind the wrong box.
+ */
+declare function getDataGridScrollAreaViewport(node: HTMLElement): HTMLElement | null;
+type DataGridTablePinnedBoundary = "top" | "bottom";
+declare function getDataGridTableRowSections<TData extends object>(table: DataGridTableInstance<TData>, rowsPinnable?: boolean): {
+  topRows: Row<DataGridFeatures, TData>[];
+  centerRows: Row<DataGridFeatures, TData>[];
+  bottomRows: Row<DataGridFeatures, TData>[];
+};
+declare function getDataGridTableResolvedRows<TData extends object>(table: DataGridTableInstance<TData>, rowsPinnable?: boolean): {
+  row: Row<DataGridFeatures, TData>;
+  pinnedBoundary?: DataGridTablePinnedBoundary;
+}[];
+declare function getDataGridTableMergedHeaderGroups<TData extends object>(table: DataGridTableInstance<TData>): {
+  id: string;
+  headers: Header<DataGridFeatures, TData, unknown>[];
+  startHeaders: Header<{
+    columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+    columnPinningFeature: import("@tanstack/react-table").TableFeature;
+    columnSizingFeature: import("@tanstack/react-table").TableFeature;
+    columnResizingFeature: import("@tanstack/react-table").TableFeature;
+    columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+    columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+    globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+    rowSortingFeature: import("@tanstack/react-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+    rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+    rowPinningFeature: import("@tanstack/react-table").TableFeature;
+    cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    sortFns: {
+      alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    };
+    columnMeta: DataGridColumnMeta<any>;
+  }, TData, unknown>[];
+  centerHeaders: Header<{
+    columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+    columnPinningFeature: import("@tanstack/react-table").TableFeature;
+    columnSizingFeature: import("@tanstack/react-table").TableFeature;
+    columnResizingFeature: import("@tanstack/react-table").TableFeature;
+    columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+    columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+    globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+    rowSortingFeature: import("@tanstack/react-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+    rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+    rowPinningFeature: import("@tanstack/react-table").TableFeature;
+    cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    sortFns: {
+      alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    };
+    columnMeta: DataGridColumnMeta<any>;
+  }, TData, unknown>[];
+  endHeaders: Header<{
+    columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+    columnPinningFeature: import("@tanstack/react-table").TableFeature;
+    columnSizingFeature: import("@tanstack/react-table").TableFeature;
+    columnResizingFeature: import("@tanstack/react-table").TableFeature;
+    columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+    columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+    globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+    rowSortingFeature: import("@tanstack/react-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+    rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+    rowPinningFeature: import("@tanstack/react-table").TableFeature;
+    cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    sortFns: {
+      alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    };
+    columnMeta: DataGridColumnMeta<any>;
+  }, TData, unknown>[];
+  coveredHeaders: Map<string, Header<{
+    columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+    columnPinningFeature: import("@tanstack/react-table").TableFeature;
+    columnSizingFeature: import("@tanstack/react-table").TableFeature;
+    columnResizingFeature: import("@tanstack/react-table").TableFeature;
+    columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+    columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+    globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+    rowSortingFeature: import("@tanstack/react-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+    rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+    rowPinningFeature: import("@tanstack/react-table").TableFeature;
+    cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+    facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+    sortFns: {
+      alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+      textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    };
+    columnMeta: DataGridColumnMeta<any>;
+  }, TData, unknown>[]>;
+}[];
+declare function renderDataGridTableHeadCellContent<TData extends object>(header: Header<DataGridFeatures, TData, unknown>): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+declare function getDataGridHeadCellResizeHeader<TData extends object>(header: Header<DataGridFeatures, TData, unknown>, coveredHeaders?: Header<DataGridFeatures, TData, unknown>[]): Header<{
+  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+  columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+  columnPinningFeature: import("@tanstack/react-table").TableFeature;
+  columnSizingFeature: import("@tanstack/react-table").TableFeature;
+  columnResizingFeature: import("@tanstack/react-table").TableFeature;
+  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+  rowSortingFeature: import("@tanstack/react-table").TableFeature;
+  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+  rowPinningFeature: import("@tanstack/react-table").TableFeature;
+  cellSelectionFeature: import("@tanstack/react-table").TableFeature;
+  sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  sortFns: {
+    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+  };
+  columnMeta: DataGridColumnMeta<any>;
+}, TData, unknown>;
+declare function getDataGridHeadCellSizeVar<TData extends object>(header: Header<DataGridFeatures, TData, unknown>, coveredHeaders?: Header<DataGridFeatures, TData, unknown>[]): string;
+declare function hasDataGridTableRightPinnedColumns<TData extends object>(table: DataGridTableInstance<TData>): boolean;
+declare function DataGridTableFillHeadCell({ rowSpan }?: {
+  /** Multi-level headers render one fill cell spanning every head row. */
+  rowSpan?: number;
+}): import("react").JSX.Element | null;
+declare function DataGridTableFillBodyCell(): import("react").JSX.Element | null;
+/**
+ * The quick-create affordance, rendered as the body's last row when
+ * `onRowCreate` is set: one full-width ghost button, the Notion/Airtable
+ * "+ New" idiom. What the click creates stays consumer-owned.
+ */
+declare function DataGridTableAddRow(): import("react").JSX.Element | null;
+declare function DataGridTableBase({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableViewport({ children, className, viewportRef, style }: {
+  children: ReactNode;
+  className?: string;
+  viewportRef?: Ref<HTMLDivElement>;
+  style?: CSSProperties;
+}): import("react").JSX.Element;
+declare function DataGridTableHead({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableHeadRow({ children, rowId }: {
+  children: ReactNode;
+  rowId: string;
+}): import("react").JSX.Element;
+declare function DataGridTableHeadRowCell<TData extends object>({ children, header, coveredHeaders, dndRef, dndStyle }: {
+  children: ReactNode;
+  header: Header<DataGridFeatures, TData, unknown>;
+  /** Headers this cell spans through meta.headerColSpan; they render none. */
+  coveredHeaders?: Header<DataGridFeatures, TData, unknown>[];
+  dndRef?: React.Ref<HTMLTableCellElement>;
+  dndStyle?: CSSProperties;
+}): import("react").JSX.Element;
+declare function DataGridTableHeadRowCellResize<TData extends object>({ header }: {
+  header: Header<DataGridFeatures, TData, unknown>;
+}): import("react").JSX.Element;
+declare function DataGridTableRowSpacer(): import("react").JSX.Element;
+declare function DataGridTableBody({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableFoot({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableFootRow({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableFootRowCell({ children, colSpan, className }: {
+  children?: ReactNode;
+  colSpan?: number;
+  className?: string;
+}): import("react").JSX.Element;
+declare function DataGridTableBodyRowSkeleton({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableBodyRowSkeletonCell<TData extends object>({ children, column }: {
+  children: ReactNode;
+  column: Column<DataGridFeatures, TData, unknown>;
+}): import("react").JSX.Element;
+declare function DataGridTableBodyRow<TData extends object>({ children, row, pinnedBoundary, rowRef, dndRef, dndStyle, dndDragging, dataIndex }: {
+  children: ReactNode;
+  row: Row<DataGridFeatures, TData>;
+  pinnedBoundary?: DataGridTablePinnedBoundary;
+  rowRef?: React.Ref<HTMLTableRowElement>;
+  dndRef?: React.Ref<HTMLTableRowElement>;
+  dndStyle?: CSSProperties;
+  dndDragging?: boolean;
+  dataIndex?: number;
+}): import("react").JSX.Element;
+declare function DataGridTableBodyRowExpandded<TData extends object>({ row }: {
+  row: Row<DataGridFeatures, TData>;
+}): import("react").JSX.Element | null;
+declare function DataGridTableBodyRowCell<TData extends object>({ children, cell, dndRef, dndStyle, columnIndex }: {
+  children: ReactNode;
+  cell: Cell<DataGridFeatures, TData, unknown>;
+  dndRef?: React.Ref<HTMLTableCellElement>;
+  dndStyle?: CSSProperties;
+  /** Center-column index under column virtualization; data-column-index. */
+  columnIndex?: number;
+}): import("react").JSX.Element;
+declare function DataGridTableRenderedRow<TData extends object>({ row, pinnedBoundary, rowRef, rowIndex, centerWindow }: {
+  row: Row<DataGridFeatures, TData>;
+  pinnedBoundary?: DataGridTablePinnedBoundary;
+  rowRef?: React.Ref<HTMLTableRowElement>;
+  /** Virtualized list index, rendered as data-index for measureElement. */
+  rowIndex?: number;
+  /**
+   * Column-virtualization window over the CENTER cells: only the inclusive
+   * [start, end] slice renders, and each flank collapses into one colSpan
+   * spacer. The spacers carry no width of their own - the colgroup stays
+   * complete, so under table-fixed the browser sizes them from the col
+   * elements they span and the layout cannot drift.
+   */
+  centerWindow?: {
+    start: number;
+    end: number;
+  };
+}): import("react").JSX.Element;
+declare function DataGridTableEmpty(): import("react").JSX.Element;
+declare function DataGridTableLoader(): import("react").JSX.Element;
+declare function DataGridTableRowPin<TData extends object>({ row }: {
+  row: Row<DataGridFeatures, TData>;
+}): import("react").JSX.Element;
+/**
+ * Selection cell.
+ *
+ * Selection is read through `row.getIsSelected()`, a builder call on a row
+ * that keeps its identity across renders. A consumer's compiled component
+ * around this checkbox caches it against that row and never renders it
+ * again, which shows up as checkboxes that do not respond to clicks.
+ * Subscribing to the row-selection atom makes selection a dependency of its
+ * own. Note the standalone `Subscribe` rather than `table.Subscribe`: inside a
+ * cell template the `table` handed to the column def is the core `Table`, which
+ * has no `Subscribe` attached.
+ */
+declare function DataGridTableRowSelect<TData extends object>({ row }: {
+  row: Row<DataGridFeatures, TData>;
+}): import("react").JSX.Element;
+declare function DataGridTableRowSelectAll(): import("react").JSX.Element;
+declare function DataGridTableRowExpand<TData extends object>({ row, indent, className, children }: {
+  row: Row<DataGridFeatures, TData>;
+  /** Horizontal offset in px applied per tree depth level. */
+  indent?: number;
+  className?: string;
+  /** Custom toggle icon; replaces the default chevron. */
+  children?: ReactNode;
+}): import("react").JSX.Element;
+declare function DataGridTableHeader<TData extends object>(): import("react").JSX.Element;
+declare function DataGridTable<TData extends object>({ footerContent, renderHeader }: {
+  footerContent?: ReactNode;
+  renderHeader?: boolean;
+}): import("react").JSX.Element;
+declare function DataGridTableDnd<TData extends object>({ handleDragEnd, footerContent, accessibility }: {
+  handleDragEnd: (event: DragEndEvent) => void;
+  footerContent?: ReactNode;
+  /**
+   * Forwarded to dnd-kit's `DndContext`: its screen-reader instructions and
+   * live-region announcements, which default to dnd-kit's English strings.
+   */
+  accessibility?: DndContextProps["accessibility"];
+}): import("react").JSX.Element;
+/**
+ * Tree metadata attached to every sortable row, readable from
+ * `active.data.current` / `over.data.current` in any drag event. Cross-parent
+ * drops can be resolved from it without re-deriving the shape of the table.
+ */
+type DataGridTableDndRowData = {
+  type: "data-grid-row";
+  /** Tree depth, 0 for root rows. */
+  depth: number;
+  /** Index within the parent's children, or within the root rows. */
+  index: number;
+  /** Parent row id, or null for root rows. */
+  parentId: string | null;
+};
+/**
+ * Per-row render slot for drop indicators and depth guides. The returned node
+ * is positioned over the row, so it never adds a column, shifts striping, or
+ * gets clipped by a truncating resizable cell.
+ */
+type DataGridTableDndRowDecoration<TData extends object> = (context: {
+  row: Row<DataGridFeatures, TData>;
+  isDragging: boolean;
+  isOver: boolean;
+}) => ReactNode;
+declare function DataGridTableDndRowHandle({ className, disabled, disabledLabel }: {
+  className?: string;
+  /**
+   * Renders the grip inert instead of withdrawing it. A grid that reorders on
+   * one truth (manual order) and sorts on another cannot honour both at once,
+   * but dropping the handle entirely collapses the gutter and reads as broken
+   * rather than as unavailable. Keep the column's shape, mute the control.
+   */
+  disabled?: boolean;
+  /** Announced and shown on hover in place of the drag affordance. */
+  disabledLabel?: string;
+}): import("react").JSX.Element;
+declare function DataGridTableDndRows<TData extends object>({ handleDragEnd, dataIds, footerContent, collisionDetection, modifiers, sortingStrategy, renderRowDecoration, dropIndicator, onDragStart, onDragMove, onDragOver, onDragCancel, accessibility }: {
+  handleDragEnd: (event: DragEndEvent) => void;
+  dataIds: UniqueIdentifier[];
+  footerContent?: ReactNode;
+  /** Overrides the default `closestCenter` strategy. */
+  collisionDetection?: CollisionDetection;
+  /**
+   * Replaces the default axis restriction, e.g. drop `restrictToVerticalAxis`
+   * to allow the horizontal gesture that tree re-parenting relies on. The
+   * table container clamp is always applied after these, so a dragged row
+   * cannot leave the grid.
+   */
+  modifiers?: Modifier[];
+  /**
+   * Replaces the default `verticalListSortingStrategy`. Return null from a
+   * strategy to leave every row exactly where it is. A tree needs that: its drop
+   * is either INTO the hovered row or BETWEEN two rows, and which one it is
+   * flips as the pointer crosses a single row, so a gap that opens for one and
+   * shuts for the other flickers the whole surface. Such a caller draws its own
+   * insertion line instead, and pairs this with a modifier that holds the
+   * carried row still, since a gap nothing moves into is just a hole.
+   */
+  sortingStrategy?: SortingStrategy;
+  /** Per-row slot for drop indicators and depth guides. */
+  renderRowDecoration?: DataGridTableDndRowDecoration<TData>;
+  /**
+   * Draws a line on the seam the carried row would land on. On by default;
+   * pass `false` when `renderRowDecoration` paints its own insertion affordance
+   * and the two would compete.
+   */
+  dropIndicator?: boolean;
+  onDragStart?: (event: DragStartEvent) => void;
+  onDragMove?: (event: DragMoveEvent) => void;
+  onDragOver?: (event: DragOverEvent) => void;
+  onDragCancel?: (event: DragCancelEvent) => void;
+  /**
+   * Forwarded to dnd-kit's `DndContext`: its screen-reader instructions and
+   * live-region announcements, which default to dnd-kit's English strings.
+   */
+  accessibility?: DndContextProps["accessibility"];
+}): import("react").JSX.Element;
+type DataGridTableVirtualScrollElements = {
+  containerElement: HTMLDivElement | null;
+  scrollElement: HTMLElement | null;
+};
+type DataGridTableVirtualScrollAlignment = "auto" | "center" | "start" | "end";
+interface DataGridTableColumnVirtualizerOptions {
+  /** Off unless explicitly true; a column window is opt-in. */
+  enabled?: boolean;
+  overscan?: number;
+}
+type DataGridTableVirtualizerOptions<TData extends object> = Omit<VirtualizerOptions<HTMLElement, HTMLTableRowElement>, "count" | "estimateSize" | "getItemKey" | "getScrollElement"> & {
+  estimateSize?: (index: number, row: Row<DataGridFeatures, TData>) => number;
+  getItemKey?: (index: number, row: Row<DataGridFeatures, TData>) => string | number;
+  getScrollElement?: (elements: DataGridTableVirtualScrollElements) => HTMLElement | null;
+};
+interface DataGridTableVirtualProps<TData extends object> {
+  height?: number | string;
+  estimateSize?: number;
+  overscan?: number;
+  /** Scroll animation used when revealing a controlled target row. */
+  scrollBehavior?: ScrollBehavior;
+  /** Alignment used when revealing a controlled target row. Defaults to auto. */
+  scrollToRowAlign?: DataGridTableVirtualScrollAlignment;
+  /** Index within the center (non-pinned) row section to reveal. */
+  scrollToRowIndex?: number;
+  /**
+   * Opt-in horizontal virtualization of the CENTER columns. Activates only
+   * under a fixed table layout with a single ungrouped header row; pinned
+   * columns stay mounted, and anything else falls back to full-column
+   * rendering. `scrollBehavior` is shared with controlled row scrolling.
+   */
+  columnVirtualizerOptions?: DataGridTableColumnVirtualizerOptions;
+  /** Alignment used when revealing a controlled target column. */
+  scrollToColumnAlign?: DataGridTableVirtualScrollAlignment;
+  /** Index within the center (non-pinned) visible leaf columns to reveal. */
+  scrollToColumnIndex?: number;
+  footerContent?: ReactNode;
+  renderHeader?: boolean;
+  onFetchMore?: () => void;
+  isFetchingMore?: boolean;
+  hasMore?: boolean;
+  fetchMoreOffset?: number;
+  virtualizerOptions?: DataGridTableVirtualizerOptions<TData>;
+}
+declare function DataGridTableVirtual<TData extends object>({ height, estimateSize, overscan, scrollBehavior, scrollToRowAlign, scrollToRowIndex, columnVirtualizerOptions, scrollToColumnAlign, scrollToColumnIndex, footerContent, renderHeader, onFetchMore, isFetchingMore, hasMore, fetchMoreOffset, virtualizerOptions }: DataGridTableVirtualProps<TData>): import("react").JSX.Element;
+interface Transaction {
+  id: string;
+  name: string;
+  network: string;
+  reference: string;
+  date: string;
+  amount: number;
+}
+export declare const TRANSACTIONS: Transaction[];
+/** A Mobile Money statement: sortable columns, cell borders, pagination (5 per page). */
+export declare function TransactionsExample({ data }: {
+  data?: Transaction[];
+}): import("react").JSX.Element;
+export { DataGrid, DataGridCellSelection, type DataGridCellSelectionApi, DataGridColumnFilter, type DataGridColumnFilterProps, DataGridColumnHeader, type DataGridColumnHeaderProps, DataGridColumnVisibility, DataGridContainer, type DataGridFocusCellOptions, DataGridPagination, type DataGridPaginationProps, type DataGridPasteTarget, DataGridProvider, DataGridScrollArea, type DataGridScrollAreaOrientation, type DataGridScrollAreaProps, DataGridSelectionBar, DataGridTable, DataGridTableAddRow, DataGridTableBase, DataGridTableBody, DataGridTableBodyRow, DataGridTableBodyRowCell, DataGridTableBodyRowExpandded, DataGridTableBodyRowSkeleton, DataGridTableBodyRowSkeletonCell, DataGridTableDnd, type DataGridTableDndRowData, type DataGridTableDndRowDecoration, DataGridTableDndRowHandle, DataGridTableDndRows, DataGridTableEmpty, DataGridTableFillBodyCell, DataGridTableFillHeadCell, DataGridTableFoot, DataGridTableFootRow, DataGridTableFootRowCell, DataGridTableHead, DataGridTableHeadRow, DataGridTableHeadRowCell, DataGridTableHeadRowCellResize, DataGridTableHeader, DataGridTableLoader, type DataGridTablePinnedBoundary, DataGridTableRenderedRow, DataGridTableRowExpand, DataGridTableRowPin, DataGridTableRowSelect, DataGridTableRowSelectAll, DataGridTableRowSpacer, DataGridTableViewport, DataGridTableVirtual, type DataGridTableVirtualProps, type DataGridTableVirtualScrollAlignment, type DataGridTableVirtualScrollElements, type DataGridTableVirtualizerOptions, type Transaction, buildDataGridClearDetails, buildDataGridPasteDetails, getDataGridActiveRegionGrid, getDataGridHeadCellResizeHeader, getDataGridHeadCellSizeVar, getDataGridScrollAreaViewport, getDataGridTableMergedHeaderGroups, getDataGridTableResolvedRows, getDataGridTableRowSections, getDataGridTreeIndentStyle, getDataGridVisibleSelectedCellCount, getPinningStyles, hasDataGridTableRightPinnedColumns, invertDataGridCellsChange, parseDataGridClipboardText, renderDataGridTableHeadCellContent, serializeDataGridClipboardText, tileDataGridClipboardBlock, useDataGrid, useDataGridAtom };