/**
 * The visible commit state of a single cell.
 *
 * - 'idle'     — no in-flight or errored commit; cell renders saved value
 * - 'pending'  — commit in flight; cell renders pending value with subtle
 *                indicator
 * - 'error'    — commit failed; cell renders pending value with error
 *                decoration + retry
 * - 'conflict' — saved value changed underneath us between dispatch and
 *                settle; consumer must resolve
 */
type CellStatus = 'idle' | 'pending' | 'error' | 'conflict';
/**
 * One pending change handed to the consumer's `onCommit` handler.
 *
 * `previousValue` is captured at dispatch time (NOT edit-start time) so it
 * always reflects the most recent saved value — useful for sending
 * `If-Match: <prev>` style optimistic-concurrency headers.
 */
interface CellPatch<TData extends RowData = RowData, TValue = unknown> {
    rowId: string;
    columnId: string;
    /** The value the user typed. */
    value: TValue;
    /** The most recent saved value at the moment we dispatched. */
    previousValue: TValue;
    /** The full row snapshot at dispatch time. */
    row: TData;
    /**
     * Aborts when the user starts a new commit on the same cell. Consumers
     * with cancellable APIs (`fetch(url, { signal })`) can wire this through.
     */
    signal: AbortSignal;
}
/**
 * What `onCommit` may return. `void` (or no return) means "the values you
 * received are now the saved values". Returning `resolved` lets the server
 * normalise/transform values before they replace the pending state.
 */
type CommitResult = void | {
    /** rowId → colId → resolved value */
    resolved?: Record<string, Record<string, unknown>>;
};
/**
 * The signature of the table-level `onCommit` option and per-column `commit`
 * override.
 */
type OnCommitFn<TData extends RowData = RowData> = (patches: CellPatch<TData>[]) => Promise<CommitResult> | CommitResult;
/**
 * One in-flight, errored, or conflicted cell. Missing entry = idle status —
 * we never write `{ status: 'idle' }` records.
 */
interface CommitRecord {
    status: 'pending' | 'error' | 'conflict';
    pendingValue: unknown;
    /** Captured at dispatch time. Used for conflict detection and `If-Match`. */
    previousValue: unknown;
    /** Monotonic per-table. Stale settlements are dropped. */
    opId: number;
    /** Only set when status === 'error'. */
    errorMessage?: string;
    /** Only set when status === 'conflict'. The new saved value we collided with. */
    conflictWith?: unknown;
    /** AbortController for cancellable consumer handlers. */
    abortController: AbortController;
}
interface CommitsSlice {
    /** rowId → colId → record. Missing entry = idle. */
    cells: Record<string, Record<string, CommitRecord>>;
    /** Monotonic counter; allocated by the coordinator. */
    nextOpId: number;
}

type RowData = Record<string, any>;
type Updater<T> = T | ((prev: T) => T);
type OnChangeFn<T> = (updater: Updater<T>) => void;
type DeepKeys<T> = unknown extends T ? string : T extends Record<string, any> ? {
    [K in keyof T & string]: T[K] extends Record<string, any> ? `${K}` | `${K}.${DeepKeys<T[K]>}` : `${K}`;
}[keyof T & string] : never;
type DeepValue<T, K> = K extends `${infer A}.${infer B}` ? A extends keyof T ? DeepValue<T[A], B> : never : K extends keyof T ? T[K] : never;
interface TableFeature<TData extends RowData = RowData> {
    getDefaultOptions?: (table: Table<TData>) => Partial<TableOptionsResolved<TData>>;
    getInitialState?: (state: TableState) => TableState;
    getDefaultColumnDef?: () => Partial<ColumnDef<TData, unknown>>;
    createTable?: (table: Table<TData>) => void;
    createColumn?: (column: Column<TData, unknown>, table: Table<TData>) => void;
    createRow?: (row: Row<TData>, table: Table<TData>) => void;
    createCell?: (cell: Cell<TData, unknown>, column: Column<TData, unknown>, row: Row<TData>, table: Table<TData>) => void;
}
type ColumnDefBase<TData extends RowData, TValue = unknown> = {
    id?: string;
    header?: string | ((ctx: HeaderContext<TData, TValue>) => unknown);
    footer?: string | ((ctx: HeaderContext<TData, TValue>) => unknown);
    cell?: string | ((ctx: CellContext<TData, TValue>) => unknown);
    meta?: ColumnMeta;
};
type AccessorKeyColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & {
    accessorKey: DeepKeys<TData> & string;
    accessorFn?: never;
} & ColumnDefExtensions<TData, TValue>;
type AccessorFnColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & {
    accessorKey?: never;
    accessorFn: (row: TData, index: number) => TValue;
    id: string;
} & ColumnDefExtensions<TData, TValue>;
type DisplayColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & {
    accessorKey?: never;
    accessorFn?: never;
    id: string;
} & ColumnDefExtensions<TData, TValue>;
type GroupColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & {
    columns: ColumnDef<TData, any>[];
} & Partial<ColumnDefExtensions<TData, TValue>>;
type ColumnDef<TData extends RowData, TValue = unknown> = AccessorKeyColumnDef<TData, TValue> | AccessorFnColumnDef<TData, TValue> | DisplayColumnDef<TData, TValue> | GroupColumnDef<TData, TValue>;
interface ColumnDefExtensions<TData extends RowData, TValue = unknown> {
    size?: number;
    minSize?: number;
    maxSize?: number;
    /**
     * Upper bound for USER drag-resize (defaults to `maxSize`). `maxSize` still
     * caps auto-sizing/stretch; set this (e.g. `Number.POSITIVE_INFINITY`, or via
     * `defaultColumnDef` for app-wide) to let a human drag a column past its
     * auto-size cap.
     */
    resizeMaxSize?: number;
    flex?: number;
    /**
     * Opt out of the React `autoColumnWidth` feature for this column. When `false`
     * (or when an explicit `size` is set) the column keeps its width and is
     * excluded from content measurement and squishing. Passive flag — no core
     * logic reads it; the React adapter honors it.
     */
    enableAutoSize?: boolean;
    /**
     * React `autoColumnWidth` measurement override: the string to MEASURE for this
     * column's content width (measured with the body font, plus cell padding and
     * the sort-indicator allowance, exactly like a normal value). Use this when the
     * displayed cell differs from the raw accessor value (a formatter or custom
     * `cell` renderer) so auto-sizing measures what the user actually sees instead
     * of the underlying value. Passive flag — only the React adapter reads it.
     */
    autoSizeText?: (row: Row<TData>) => string;
    /**
     * React `autoColumnWidth` measurement override: an EXACT natural pixel width for
     * this row's cell. When present it bypasses text measurement entirely and is
     * used verbatim (no padding or sort-indicator is added). The column's natural
     * width is the max of this over sampled rows and the header's measured width.
     * Takes precedence over {@link autoSizeText}. Passive flag — only the React
     * adapter reads it.
     */
    autoSizeWidth?: (row: Row<TData>) => number;
    enableSorting?: boolean;
    sortingFn?: SortingFnOption<TData>;
    sortDescFirst?: boolean;
    sortUndefined?: false | -1 | 1 | 'first' | 'last';
    invertSorting?: boolean;
    enableColumnFilter?: boolean;
    enableGlobalFilter?: boolean;
    filterFn?: FilterFnOption<TData>;
    enableHiding?: boolean;
    /**
     * When true, this column's visibility cannot be toggled to hidden.
     * `toggleVisibility(false)` becomes a no-op; `toggleVisibility(true)` still works.
     * Useful for columns that should always remain visible (e.g. checkbox, actions).
     */
    lockVisible?: boolean;
    enablePinning?: boolean;
    enableResizing?: boolean;
    enableReorder?: boolean;
    enableMultiRowSelection?: boolean;
    /**
     * Controls spreadsheet-style cell range selection for this column.
     * Table-level `enableCellSelection` must also be enabled.
     */
    enableCellSelection?: boolean;
    enableGrouping?: boolean;
    getGroupingValue?: (row: TData) => unknown;
    aggregationFn?: AggregationFnOption<TData>;
    aggregatedCell?: string | ((ctx: CellContext<TData, TValue>) => unknown);
    editable?: boolean | ((row: Row<TData>) => boolean);
    editConfig?: CellEditConfig<TData, TValue>;
    /**
     * Per-column commit handler (Task #10). Takes precedence over
     * `table.options.onCommit` for cells in this column. Use for bespoke
     * endpoints, file uploads, etc.
     */
    commit?: (patch: CellPatch<TData, TValue>) => Promise<CommitResult> | CommitResult;
    rowSpan?: (row: Row<TData>, rows: Row<TData>[], rowIndex: number) => number | undefined;
    /**
     * Horizontal alignment for this column's header AND body cells. Emits
     * `data-align` on both, so one declaration centralizes what would otherwise be
     * a per-cell style. Right-aligned body cells also get tabular figures, which
     * is what numeric columns want.
     */
    align?: 'left' | 'center' | 'right';
    cellClassName?: string | ((ctx: CellContext<TData, TValue>) => string | undefined);
    cellStyle?: React.CSSProperties | ((ctx: CellContext<TData, TValue>) => React.CSSProperties | undefined);
    /**
     * Name of a reusable cell config supplied by framework adapters.
     * React resolves this through `YableProvider` / `useTable` config profiles.
     */
    cellConfig?: string | string[];
    headerClassName?: string | ((ctx: HeaderContext<TData, TValue>) => string | undefined);
    footerClassName?: string;
    tooltip?: boolean | string | ((ctx: CellContext<TData, TValue>) => string);
    headerTooltip?: string;
    tooltipDelay?: number;
    cellType?: 'badge' | 'currency' | 'status' | 'numeric' | 'rating' | 'boolean' | 'progress' | 'date' | 'link';
    cellTypeProps?: Record<string, unknown>;
    measureRecipe?: {
        /** CSS font string, e.g. "500 13px Inter" */
        font: string;
        /** Line height in px */
        lineHeight: number;
        /** Cell vertical padding (top + bottom) in px */
        padding: number;
        /**
         * If true, this column does not wrap text — Pretext skips text measurement
         * and contributes a constant `lineHeight + padding` per row.
         */
        fixedHeight?: boolean;
    };
    enableCellFlash?: boolean;
    flashDuration?: number;
    flashUpColor?: string;
    flashDownColor?: string;
}
interface ColumnMeta {
    alwaysEditable?: boolean;
    [key: string]: unknown;
}
type CellEditType = 'text' | 'number' | 'select' | 'toggle' | 'date' | 'checkbox' | 'custom';
interface CellEditConfig<TData extends RowData, TValue = unknown> {
    type: CellEditType;
    options?: {
        label: string;
        value: unknown;
    }[];
    getOptions?: (row: Row<TData>) => {
        label: string;
        value: unknown;
    }[];
    validate?: (value: TValue, row: Row<TData>) => string | null;
    parse?: (inputValue: string) => TValue;
    format?: (value: TValue) => string;
    placeholder?: string;
    render?: (props: CellEditRenderProps<TData, TValue>) => unknown;
    /**
     * Per-column commit handler. Fires once for every committed value in this
     * column — on single-cell commit, full-row commit, and `commitAllPending()` —
     * with the (pre-commit) row and the newly committed value.
     *
     * Lets the column-id → data-field mapping live on the column def instead of a
     * `switch (columnId)` inside a table-level `onEditCommit`/`onCommit` handler.
     * This is the recommended shape for nested/derived accessors
     * (`columnHelper.accessor((r) => r.a.b, { id })`), whose committed value is
     * keyed by column **id**, not by a `Partial<TData>` data path. Fires
     * regardless of whether `onEditCommit`/`onCommit` is also set; if both are
     * defined they both run, so pick one owner per column.
     */
    commit?: (row: Row<TData>, value: TValue) => void;
}
interface CellEditRenderProps<TData extends RowData, TValue = unknown> {
    value: TValue;
    onChange: (value: TValue) => void;
    onCommit: () => void;
    onCancel: () => void;
    row: Row<TData>;
    column: Column<TData, TValue>;
    isValid: boolean;
    validationError: string | null;
}
interface TableOptions<TData extends RowData> {
    data: TData[];
    columns: ColumnDef<TData, any>[];
    /**
     * Default column definition values applied to every column.
     * Column-specific values take precedence over these defaults.
     */
    defaultColumnDef?: Partial<ColumnDefBase<TData, unknown>> & Partial<ColumnDefExtensions<TData, unknown>>;
    state?: Partial<TableState>;
    onStateChange?: OnChangeFn<TableState>;
    initialState?: Partial<TableState>;
    getRowId?: (row: TData, index: number, parent?: Row<TData>) => string;
    debugAll?: boolean;
    locale?: Record<string, string>;
    getCoreRowModel?: (table: Table<TData>) => () => RowModel<TData>;
    getFilteredRowModel?: (table: Table<TData>) => () => RowModel<TData>;
    getSortedRowModel?: (table: Table<TData>) => () => RowModel<TData>;
    getPaginationRowModel?: (table: Table<TData>) => () => RowModel<TData>;
    getGroupedRowModel?: (table: Table<TData>) => () => RowModel<TData>;
    getExpandedRowModel?: (table: Table<TData>) => () => RowModel<TData>;
    getFacetedRowModel?: (table: Table<TData>, columnId: string) => () => RowModel<TData>;
    getFacetedUniqueValues?: (table: Table<TData>, columnId: string) => () => Map<unknown, number>;
    getFacetedMinMaxValues?: (table: Table<TData>, columnId: string) => () => [number, number] | undefined;
    enableSorting?: boolean;
    enableMultiSort?: boolean;
    enableSortingRemoval?: boolean;
    maxMultiSortColCount?: number;
    manualSorting?: boolean;
    sortingFns?: Record<string, SortingFn<TData>>;
    onSortingChange?: OnChangeFn<SortingState>;
    isMultiSortEvent?: (e: unknown) => boolean;
    /**
     * Native post-sort hook (AG-parity `postSortRows`). Runs after the sorted row
     * model is built, receiving the sorted rows array. Return a reordered array,
     * or mutate the provided array in place, to control final render order — e.g.
     * keeping child rows grouped under their parents. Runs whenever provided,
     * including when no sorting is active. Skipped under `manualSorting`.
     */
    postSortRows?: (rows: Row<TData>[]) => Row<TData>[] | void;
    enableFilters?: boolean;
    enableColumnFilters?: boolean;
    enableGlobalFilter?: boolean;
    manualFiltering?: boolean;
    filterFns?: Record<string, FilterFn<TData>>;
    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
    onGlobalFilterChange?: OnChangeFn<string>;
    globalFilterFn?: FilterFnOption<TData>;
    getColumnCanGlobalFilter?: (column: Column<TData, unknown>) => boolean;
    manualPagination?: boolean;
    pageCount?: number;
    rowCount?: number;
    autoResetPageIndex?: boolean;
    onPaginationChange?: OnChangeFn<PaginationState>;
    enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
    enableMultiRowSelection?: boolean | ((row: Row<TData>) => boolean);
    enableSubRowSelection?: boolean | ((row: Row<TData>) => boolean);
    /** Toggle row selection when the user clicks a non-interactive part of the row. */
    enableRowClickSelection?: boolean;
    /** Enable spreadsheet-style cell range selection. Can be disabled globally or per column. */
    enableCellSelection?: boolean;
    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
    enableHiding?: boolean;
    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
    /**
     * When true (default), columns cannot be hidden while a column drag is in
     * progress. Prevents accidental column hiding caused by `dragleave` events
     * during reorder operations. Set to `false` to allow hiding during drag.
     */
    suppressDragHidesColumns?: boolean;
    enableColumnReorder?: boolean;
    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
    enableColumnPinning?: boolean;
    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
    enableColumnResizing?: boolean;
    columnResizeMode?: 'onChange' | 'onEnd';
    columnResizeDirection?: 'ltr' | 'rtl';
    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
    onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
    enableExpanding?: boolean;
    getSubRows?: (row: TData, index: number) => TData[] | undefined;
    getRowCanExpand?: (row: Row<TData>) => boolean;
    manualExpanding?: boolean;
    paginateExpandedRows?: boolean;
    onExpandedChange?: OnChangeFn<ExpandedState>;
    renderDetailPanel?: (row: Row<TData>) => unknown;
    enableRowPinning?: boolean | ((row: Row<TData>) => boolean);
    keepPinnedRows?: boolean;
    onRowPinningChange?: OnChangeFn<RowPinningState>;
    enableGrouping?: boolean;
    manualGrouping?: boolean;
    onGroupingChange?: OnChangeFn<GroupingState>;
    enableCellEditing?: boolean;
    onEditingChange?: OnChangeFn<EditingState>;
    onEditCommit?: (changes: Record<string, Partial<TData>>) => void;
    /**
     * Async commit handler. Receives a batch of patches; resolve to mark
     * success, throw to mark failure. Throw a `CommitError` for per-cell
     * precision. See features/commits/types.ts for `CellPatch` shape.
     */
    onCommit?: OnCommitFn<TData>;
    /**
     * Default true. Set to false to make the grid accumulate pending edits
     * and only fire `onCommit` when `table.commit()` is called.
     */
    autoCommit?: boolean;
    /**
     * What happens when a row commit partially fails.
     * - 'failed' (default) — failed cells stay errored, succeeded cells clear
     * - 'batch'            — entire row stays errored until the whole row is retried
     */
    rowCommitRetryMode?: 'failed' | 'batch';
    enableKeyboardNavigation?: boolean;
    onKeyboardNavigationChange?: OnChangeFn<KeyboardNavigationState>;
    enableVirtualization?: boolean;
    rowHeight?: number | ((index: number) => number);
    overscan?: number;
    estimateRowHeight?: number;
    /** Pre-computed row heights from Pretext measurement (Float64Array indexed by row) */
    pretextHeights?: Float64Array | null;
    /** Pre-computed prefix sums for O(log n) scroll lookups */
    pretextPrefixSums?: Float64Array | null;
    /**
     * Height in px of the virtualized scroll viewport. Without it the viewport
     * falls back to built-in heuristics (~20 rows, capped at 800px), which can
     * overflow a shorter styled container and leave a clipped-but-scrollable
     * region below it.
     */
    virtualViewportHeight?: number;
    enableExport?: boolean;
    enableUndoRedo?: boolean;
    undoStackSize?: number;
    enableClipboard?: boolean;
    clipboardOptions?: ClipboardOptions;
    enableFillHandle?: boolean;
    enableFormulas?: boolean;
    enableRowDragging?: boolean;
    onRowReorder?: (event: {
        fromIndex: number;
        toIndex: number;
        rowId: string;
    }) => void;
    getDataPath?: (row: TData) => string[];
    treeData?: boolean;
    enablePivot?: boolean;
    pivotConfig?: PivotConfig;
    rowClassName?: string | ((row: Row<TData>) => string | undefined);
    rowStyle?: React.CSSProperties | ((row: Row<TData>) => React.CSSProperties);
    onCellClick?: (event: CellClickEvent<TData>) => void;
    onCellDoubleClick?: (event: CellClickEvent<TData>) => void;
    onCellContextMenu?: (event: CellClickEvent<TData>) => void;
    onRowClick?: (event: RowClickEvent<TData>) => void;
    onRowDoubleClick?: (event: RowClickEvent<TData>) => void;
    onRowContextMenu?: (event: RowClickEvent<TData>) => void;
    onHeaderClick?: (event: HeaderClickEvent<TData>) => void;
    onHeaderContextMenu?: (event: HeaderClickEvent<TData>) => void;
}
type TableOptionsResolved<TData extends RowData> = Required<Pick<TableOptions<TData>, 'data' | 'columns' | 'state' | 'onStateChange'>> & Omit<TableOptions<TData>, 'data' | 'columns' | 'state' | 'onStateChange'>;
interface TableState {
    sorting: SortingState;
    columnFilters: ColumnFiltersState;
    globalFilter: string;
    pagination: PaginationState;
    rowSelection: RowSelectionState;
    cellSelection?: CellRangeSelectionState;
    columnVisibility: VisibilityState;
    columnOrder: ColumnOrderState;
    columnPinning: ColumnPinningState;
    columnSizing: ColumnSizingState;
    columnSizingInfo: ColumnSizingInfoState;
    expanded: ExpandedState;
    rowPinning: RowPinningState;
    grouping: GroupingState;
    editing: EditingState;
    /** Optimistic-commit slice — see features/commits/types.ts (Task #10). */
    commits: CommitsSlice;
    keyboardNavigation: KeyboardNavigationState;
    undoRedo: UndoRedoState;
    fillHandle: FillHandleState;
    formulas: FormulaState;
    rowDrag: RowDragState;
    pivot: PivotState;
}
type SortDirection = 'asc' | 'desc';
interface ColumnSort {
    id: string;
    desc: boolean;
}
type SortingState = ColumnSort[];
type SortingFn<TData extends RowData> = (rowA: Row<TData>, rowB: Row<TData>, columnId: string) => number;
type SortingFnOption<TData extends RowData> = 'auto' | SortingFn<TData> | keyof BuiltInSortingFns | (string & {});
interface BuiltInSortingFns {
    alphanumeric: SortingFn<RowData>;
    alphanumericCaseSensitive: SortingFn<RowData>;
    text: SortingFn<RowData>;
    textCaseSensitive: SortingFn<RowData>;
    datetime: SortingFn<RowData>;
    basic: SortingFn<RowData>;
}
interface ColumnFilter {
    id: string;
    value: unknown;
}
type ColumnFiltersState = ColumnFilter[];
type FilterFn<TData extends RowData> = (row: Row<TData>, columnId: string, filterValue: unknown, addMeta: (meta: FilterMeta) => void) => boolean;
type FilterFnOption<TData extends RowData> = FilterFn<TData> | keyof BuiltInFilterFns | (string & {});
interface BuiltInFilterFns {
    includesString: FilterFn<RowData>;
    includesStringSensitive: FilterFn<RowData>;
    equalsString: FilterFn<RowData>;
    equalsStringSensitive: FilterFn<RowData>;
    arrIncludes: FilterFn<RowData>;
    arrIncludesAll: FilterFn<RowData>;
    arrIncludesSome: FilterFn<RowData>;
    equals: FilterFn<RowData>;
    weakEquals: FilterFn<RowData>;
    inNumberRange: FilterFn<RowData>;
}
interface FilterMeta {
    itemRank?: unknown;
    [key: string]: unknown;
}
interface PaginationState {
    pageIndex: number;
    pageSize: number;
}
type RowSelectionState = Record<string, boolean>;
interface CellRange {
    start: KeyboardNavigationCell;
    end: KeyboardNavigationCell;
}
interface CellRangeSelectionState {
    range: CellRange | null;
    anchor: KeyboardNavigationCell | null;
    isDragging: boolean;
}
type VisibilityState = Record<string, boolean>;
type ColumnOrderState = string[];
interface ColumnPinningState {
    left?: string[];
    right?: string[];
}
type ColumnSizingState = Record<string, number>;
interface ColumnSizingInfoState {
    startOffset: number | null;
    startSize: number | null;
    deltaOffset: number | null;
    deltaPercentage: number | null;
    isResizingColumn: string | false;
    columnSizingStart: [string, number][];
}
type ExpandedState = Record<string, boolean> | true;
interface RowPinningState {
    top?: string[];
    bottom?: string[];
}
type GroupingState = string[];
interface EditingState {
    activeCell?: {
        rowId: string;
        columnId: string;
    };
    pendingValues: Record<string, Record<string, unknown>>;
    /** Set of row IDs currently being edited in full-row mode */
    editingRows?: string[];
}
interface KeyboardNavigationCell {
    rowIndex: number;
    columnIndex: number;
}
interface KeyboardNavigationState {
    focusedCell: KeyboardNavigationCell | null;
}
type KeyboardNavigationDirection = 'up' | 'down' | 'left' | 'right';
type KeyboardNavigationAction = {
    type: 'arrow';
    direction: KeyboardNavigationDirection;
    ctrlKey?: boolean;
} | {
    type: 'tab';
    shiftKey?: boolean;
} | {
    type: 'home';
    ctrlKey?: boolean;
} | {
    type: 'end';
    ctrlKey?: boolean;
} | {
    type: 'page';
    direction: 'up' | 'down';
    pageSize: number;
};
interface UndoRedoState {
    undoStack: UndoAction[];
    redoStack: UndoAction[];
    maxSize: number;
}
interface UndoAction {
    type: 'cell-edit';
    rowId: string;
    columnId: string;
    oldValue: unknown;
    newValue: unknown;
    timestamp: number;
}
interface RowDragState {
    /** The row id currently being dragged, or null */
    draggingRowId: string | null;
    /** The row id that is the current drop target */
    overRowId: string | null;
    /** Position of the drop indicator relative to the target row */
    dropPosition: 'before' | 'after' | null;
}
interface PivotConfig {
    /** Fields to use as row groups */
    rowFields: {
        field: string;
        label?: string;
    }[];
    /** Fields to use as column groups (generate dynamic columns) */
    columnFields: {
        field: string;
        label?: string;
    }[];
    /** Fields to aggregate as values */
    valueFields: {
        field: string;
        aggregation: string | AggregationFn<any>;
        label?: string;
    }[];
    /** Whether to show row subtotals */
    showRowSubtotals?: boolean;
    /** Whether to show column subtotals */
    showColumnSubtotals?: boolean;
    /** Whether to show grand total row */
    showGrandTotal?: boolean;
}
interface PivotState {
    /** Whether pivot mode is active */
    enabled: boolean;
    /** Pivot configuration */
    config: PivotConfig;
    /** Expanded row groups (by path key) */
    expandedRowGroups: Record<string, boolean>;
    /** Expanded column groups (by path key) */
    expandedColumnGroups: Record<string, boolean>;
}
interface ClipboardOptions {
    /** Column delimiter for copy/paste. Default: '\t' (tab, for Excel compatibility) */
    delimiter?: string;
    /** Row delimiter for copy/paste. Default: '\n' */
    rowDelimiter?: string;
    /** Include column headers when copying. Default: false */
    includeHeaders?: boolean;
}
interface FillHandleState {
    /** Whether a fill drag is in progress */
    isDragging: boolean;
    /** Source cell position (row index, column index) */
    sourceCell?: {
        rowIndex: number;
        columnIndex: number;
    };
    /** Current drag target cell position */
    targetCell?: {
        rowIndex: number;
        columnIndex: number;
    };
    /** Fill direction */
    direction?: 'down' | 'right' | 'up' | 'left';
}
interface FormulaState {
    /** Whether formulas are enabled */
    enabled: boolean;
    /** Map of cell ID -> raw formula string (e.g. '=SUM(A1:A10)') */
    formulas: Record<string, string>;
    /** Map of cell ID -> computed value */
    computedValues: Record<string, unknown>;
    /** Map of cell ID -> error message (if evaluation failed) */
    errors: Record<string, string>;
}
type AggregationFn<TData extends RowData> = (columnId: string, leafRows: Row<TData>[], childRows: Row<TData>[]) => unknown;
type AggregationFnOption<TData extends RowData> = 'sum' | 'min' | 'max' | 'extent' | 'mean' | 'median' | 'unique' | 'uniqueCount' | 'count' | AggregationFn<TData> | (string & {});
interface Table<TData extends RowData> {
    _features: TableFeature<TData>[];
    options: TableOptionsResolved<TData>;
    initialState: TableState;
    getState: () => TableState;
    setState: (updater: Updater<TableState>) => void;
    setOptions: (newOptions: Updater<TableOptionsResolved<TData>>) => void;
    reset: () => void;
    getAllColumns: () => Column<TData, unknown>[];
    getAllFlatColumns: () => Column<TData, unknown>[];
    getAllLeafColumns: () => Column<TData, unknown>[];
    getColumn: (columnId: string) => Column<TData, unknown> | undefined;
    getVisibleFlatColumns: () => Column<TData, unknown>[];
    getVisibleLeafColumns: () => Column<TData, unknown>[];
    getLeftVisibleLeafColumns: () => Column<TData, unknown>[];
    getRightVisibleLeafColumns: () => Column<TData, unknown>[];
    getCenterVisibleLeafColumns: () => Column<TData, unknown>[];
    getHeaderGroups: () => HeaderGroup<TData>[];
    getLeftHeaderGroups: () => HeaderGroup<TData>[];
    getRightHeaderGroups: () => HeaderGroup<TData>[];
    getCenterHeaderGroups: () => HeaderGroup<TData>[];
    getFooterGroups: () => HeaderGroup<TData>[];
    getLeftFooterGroups: () => HeaderGroup<TData>[];
    getRightFooterGroups: () => HeaderGroup<TData>[];
    getCenterFooterGroups: () => HeaderGroup<TData>[];
    getCoreRowModel: () => RowModel<TData>;
    getRowModel: () => RowModel<TData>;
    getRow: (id: string, searchAll?: boolean) => Row<TData>;
    getFilteredRowModel: () => RowModel<TData>;
    getPreFilteredRowModel: () => RowModel<TData>;
    getSortedRowModel: () => RowModel<TData>;
    getPreSortedRowModel: () => RowModel<TData>;
    getPaginationRowModel: () => RowModel<TData>;
    getPrePaginationRowModel: () => RowModel<TData>;
    getGroupedRowModel: () => RowModel<TData>;
    getPreGroupedRowModel: () => RowModel<TData>;
    getExpandedRowModel: () => RowModel<TData>;
    getPreExpandedRowModel: () => RowModel<TData>;
    getPageCount: () => number;
    getRowCount: () => number;
    getCanPreviousPage: () => boolean;
    getCanNextPage: () => boolean;
    previousPage: () => void;
    nextPage: () => void;
    firstPage: () => void;
    lastPage: () => void;
    setPagination: (updater: Updater<PaginationState>) => void;
    setPageIndex: (updater: Updater<number>) => void;
    setPageSize: (size: number) => void;
    resetPageIndex: (defaultState?: boolean) => void;
    resetPageSize: (defaultState?: boolean) => void;
    resetPagination: (defaultState?: boolean) => void;
    setSorting: (updater: Updater<SortingState>) => void;
    resetSorting: (defaultState?: boolean) => void;
    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
    resetColumnFilters: (defaultState?: boolean) => void;
    setGlobalFilter: (updater: Updater<string>) => void;
    resetGlobalFilter: (defaultState?: boolean) => void;
    getSelectedRowModel: () => RowModel<TData>;
    getFilteredSelectedRowModel: () => RowModel<TData>;
    getGroupedSelectedRowModel: () => RowModel<TData>;
    getIsAllRowsSelected: () => boolean;
    getIsSomeRowsSelected: () => boolean;
    getIsAllPageRowsSelected: () => boolean;
    getIsSomePageRowsSelected: () => boolean;
    toggleAllRowsSelected: (value?: boolean) => void;
    toggleAllPageRowsSelected: (value?: boolean) => void;
    getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
    getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
    setRowSelection: (updater: Updater<RowSelectionState>) => void;
    resetRowSelection: (defaultState?: boolean) => void;
    getCellSelectionRange: () => CellRange | null;
    clearCellSelection: () => void;
    selectCell: (cell: KeyboardNavigationCell, options?: {
        extend?: boolean;
        keepAnchor?: boolean;
    }) => void;
    startCellRangeSelection: (cell: KeyboardNavigationCell, options?: {
        extend?: boolean;
    }) => void;
    updateCellRangeSelection: (cell: KeyboardNavigationCell) => void;
    endCellRangeSelection: () => void;
    getIsCellSelected: (rowIndex: number, columnIndex: number) => boolean;
    getCellSelectionEdges: (rowIndex: number, columnIndex: number) => {
        top: boolean;
        right: boolean;
        bottom: boolean;
        left: boolean;
    } | null;
    setColumnVisibility: (updater: Updater<VisibilityState>) => void;
    resetColumnVisibility: (defaultState?: boolean) => void;
    toggleAllColumnsVisible: (value?: boolean) => void;
    getIsAllColumnsVisible: () => boolean;
    getIsSomeColumnsVisible: () => boolean;
    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
    resetColumnOrder: (defaultState?: boolean) => void;
    setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
    resetColumnPinning: (defaultState?: boolean) => void;
    getIsSomeColumnsPinned: (position?: 'left' | 'right') => boolean;
    setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
    setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
    resetColumnSizing: (defaultState?: boolean) => void;
    sizeColumnsToFit: (width: number) => void;
    getTotalSize: () => number;
    getLeftTotalSize: () => number;
    getRightTotalSize: () => number;
    getCenterTotalSize: () => number;
    setExpanded: (updater: Updater<ExpandedState>) => void;
    toggleAllRowsExpanded: (expanded?: boolean) => void;
    resetExpanded: (defaultState?: boolean) => void;
    getCanSomeRowsExpand: () => boolean;
    getIsAllRowsExpanded: () => boolean;
    getIsSomeRowsExpanded: () => boolean;
    getExpandedDepth: () => number;
    setRowPinning: (updater: Updater<RowPinningState>) => void;
    resetRowPinning: (defaultState?: boolean) => void;
    getTopRows: () => Row<TData>[];
    getBottomRows: () => Row<TData>[];
    getCenterRows: () => Row<TData>[];
    setGrouping: (updater: Updater<GroupingState>) => void;
    resetGrouping: (defaultState?: boolean) => void;
    startEditing: (rowId: string, columnId: string) => void;
    commitEdit: () => void;
    cancelEdit: () => void;
    setPendingValue: (rowId: string, columnId: string, value: unknown) => void;
    getPendingValue: (rowId: string, columnId: string) => unknown | undefined;
    getPendingRow: (rowId: string) => Partial<TData> | undefined;
    getAllPendingChanges: () => Record<string, Partial<TData>>;
    hasPendingChanges: () => boolean;
    commitAllPending: () => void;
    discardAllPending: () => void;
    getValidationErrors: () => Record<string, Record<string, string>>;
    isValid: () => boolean;
    setEditing: (updater: Updater<EditingState>) => void;
    resetEditing: (defaultState?: boolean) => void;
    /** Read the merged render value (pending shadows saved). */
    getCellRenderValue: (rowId: string, columnId: string) => unknown;
    /** Read the cell's commit status. */
    getCellStatus: (rowId: string, columnId: string) => 'idle' | 'pending' | 'error' | 'conflict';
    /** Error message if status === 'error'. */
    getCellErrorMessage: (rowId: string, columnId: string) => string | undefined;
    /** Conflicting saved value if status === 'conflict'. */
    getCellConflictWith: (rowId: string, columnId: string) => unknown;
    /** Manually fire all pending commits (used when autoCommit=false). */
    commit: () => Promise<void>;
    /** Retry a single failed/conflicted cell. */
    retryCommit: (rowId: string, columnId: string) => Promise<void>;
    /** Drop a single pending/error/conflict entry without retrying. */
    dismissCommit: (rowId: string, columnId: string) => void;
    /** Drop all pending/error/conflict entries. */
    dismissAllCommits: () => void;
    getFocusedCell: () => KeyboardNavigationCell | null;
    setFocusedCell: (cell: KeyboardNavigationCell | null) => void;
    clearFocusedCell: () => void;
    moveFocus: (action: KeyboardNavigationAction) => KeyboardNavigationCell | null;
    setKeyboardNavigation: (updater: Updater<KeyboardNavigationState>) => void;
    resetKeyboardNavigation: (defaultState?: boolean) => void;
    exportData: (options?: ExportOptions) => string;
    undo: () => void;
    redo: () => void;
    canUndo: () => boolean;
    canRedo: () => boolean;
    clearUndoHistory: () => void;
    copyToClipboard: (options?: ClipboardOptions) => string;
    pasteFromClipboard: (text: string, targetRowId: string, targetColumnId: string, options?: ClipboardOptions) => void;
    cutCells: (options?: ClipboardOptions) => string;
    fillRange: (sourceRange: {
        startRow: number;
        startCol: number;
        endRow: number;
        endCol: number;
    }, targetRange: {
        startRow: number;
        startCol: number;
        endRow: number;
        endCol: number;
    }) => void;
    setFormula: (rowId: string, columnId: string, formula: string) => void;
    getFormula: (rowId: string, columnId: string) => string | undefined;
    evaluateFormulas: () => void;
    moveRow: (fromIndex: number, toIndex: number) => void;
    startRowEditing: (rowId: string) => void;
    commitRowEdit: (rowId: string) => void;
    cancelRowEdit: (rowId: string) => void;
    isRowEditing: (rowId: string) => boolean;
    getEditingRows: () => string[];
    getEditableColumnIds: (rowId: string) => string[];
    getPivotRowModel: () => RowModel<TData>;
    /** Signal that a column header drag has started. */
    setColumnDragActive: (active: boolean) => void;
    /** Returns true while a column header drag is in progress. */
    getIsColumnDragActive: () => boolean;
    /**
     * Ask any active `autoColumnWidth` sizing to re-measure column content now.
     * Emits `'columns:remeasure'`. Call this after an async value merge (cell
     * values arriving from a separate query) so smart width re-sizes on the real
     * content instead of the placeholder it first saw. No-op when smart width is
     * off. Respects the provenance rule: only auto-owned widths update; user-set
     * or persisted widths are never overwritten.
     */
    remeasureColumns: (reason?: string) => void;
    events: EventEmitter<YableEventMap<TData>>;
    getLocaleString: (key: string) => string;
}
interface RowModel<TData extends RowData> {
    rows: Row<TData>[];
    flatRows: Row<TData>[];
    rowsById: Record<string, Row<TData>>;
}
interface Column<TData extends RowData, TValue = unknown> {
    id: string;
    depth: number;
    columnDef: ColumnDef<TData, TValue>;
    columns: Column<TData, unknown>[];
    parent?: Column<TData, unknown>;
    accessorFn?: (row: TData, index: number) => TValue;
    getFlatColumns: () => Column<TData, unknown>[];
    getLeafColumns: () => Column<TData, unknown>[];
    getSize: () => number;
    getStart: (position?: ColumnPinningPosition) => number;
    getAfter: (position?: ColumnPinningPosition) => number;
    getCanResize: () => boolean;
    getIsResizing: () => boolean;
    resetSize: () => void;
    getCanReorder: () => boolean;
    getCanSort: () => boolean;
    getCanMultiSort: () => boolean;
    getAutoSortingFn: () => SortingFn<TData>;
    getAutoSortDir: () => SortDirection;
    getSortingFn: () => SortingFn<TData>;
    getNextSortingOrder: () => SortDirection | false;
    getIsSorted: () => false | SortDirection;
    getSortIndex: () => number;
    clearSorting: () => void;
    toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
    getToggleSortingHandler: () => ((event: unknown) => void) | undefined;
    getCanFilter: () => boolean;
    getCanGlobalFilter: () => boolean;
    getIsFiltered: () => boolean;
    getFilterValue: () => unknown;
    getFilterIndex: () => number;
    setFilterValue: (value: unknown) => void;
    getAutoFilterFn: () => FilterFn<TData> | undefined;
    getFilterFn: () => FilterFn<TData> | undefined;
    getCanHide: () => boolean;
    getIsVisible: () => boolean;
    toggleVisibility: (value?: boolean) => void;
    getToggleVisibilityHandler: () => (event: unknown) => void;
    getCanPin: () => boolean;
    getIsPinned: () => ColumnPinningPosition | false;
    pin: (position: ColumnPinningPosition) => void;
    getPinnedIndex: () => number;
    getFacetedRowModel: () => RowModel<TData>;
    getFacetedUniqueValues: () => Map<unknown, number>;
    getFacetedMinMaxValues: () => [number, number] | undefined;
    getCanGroup: () => boolean;
    getIsGrouped: () => boolean;
    getGroupedIndex: () => number;
    toggleGrouping: () => void;
    getAutoAggregationFn: () => AggregationFn<TData> | undefined;
    getAggregationFn: () => AggregationFn<TData> | undefined;
}
type ColumnPinningPosition = 'left' | 'right' | false;
interface Header<TData extends RowData, TValue = unknown> {
    id: string;
    index: number;
    depth: number;
    column: Column<TData, TValue>;
    headerGroup: HeaderGroup<TData>;
    subHeaders: Header<TData, unknown>[];
    colSpan: number;
    rowSpan: number;
    isPlaceholder: boolean;
    placeholderId?: string;
    getLeafHeaders: () => Header<TData, unknown>[];
    getSize: () => number;
    getStart: (position?: ColumnPinningPosition) => number;
    getContext: () => HeaderContext<TData, TValue>;
    getResizeHandler: () => ((event: unknown) => void) | undefined;
}
interface HeaderGroup<TData extends RowData> {
    id: string;
    depth: number;
    headers: Header<TData, unknown>[];
}
interface HeaderContext<TData extends RowData, TValue = unknown> {
    table: Table<TData>;
    header: Header<TData, TValue>;
    column: Column<TData, TValue>;
}
interface Row<TData extends RowData> {
    id: string;
    index: number;
    original: TData;
    depth: number;
    parentId?: string;
    subRows: Row<TData>[];
    getValue: <TValue = unknown>(columnId: string) => TValue;
    renderValue: <TValue = unknown>(columnId: string) => TValue;
    getAllCells: () => Cell<TData, unknown>[];
    getVisibleCells: () => Cell<TData, unknown>[];
    getLeftVisibleCells: () => Cell<TData, unknown>[];
    getRightVisibleCells: () => Cell<TData, unknown>[];
    getCenterVisibleCells: () => Cell<TData, unknown>[];
    getIsSelected: () => boolean;
    getIsSomeSelected: () => boolean;
    getIsAllSubRowsSelected: () => boolean;
    getCanSelect: () => boolean;
    getCanMultiSelect: () => boolean;
    getCanSelectSubRows: () => boolean;
    toggleSelected: (value?: boolean, opts?: {
        selectChildren?: boolean;
    }) => void;
    getToggleSelectedHandler: () => (event: unknown) => void;
    getIsExpanded: () => boolean;
    getCanExpand: () => boolean;
    getIsGrouped: () => boolean;
    toggleExpanded: (expanded?: boolean) => void;
    getToggleExpandedHandler: () => (event: unknown) => void;
    getIsPinned: () => RowPinningPosition | false;
    getCanPin: () => boolean;
    pin: (position: RowPinningPosition, includeLeafRows?: boolean, includeParentRows?: boolean) => void;
    groupingColumnId?: string;
    groupingValue?: unknown;
    getGroupingValue: (columnId: string) => unknown;
    getLeafRows: () => Row<TData>[];
    getParentRow: () => Row<TData> | undefined;
    getTreeDepth: () => number;
    isLeaf: () => boolean;
}
type RowPinningPosition = 'top' | 'bottom' | false;
interface Cell<TData extends RowData, TValue = unknown> {
    id: string;
    row: Row<TData>;
    column: Column<TData, TValue>;
    getValue: () => TValue;
    renderValue: () => TValue;
    getContext: () => CellContext<TData, TValue>;
    getIsEditing: () => boolean;
    getIsAlwaysEditable: () => boolean;
    getRowSpan: () => number | undefined;
}
interface CellContext<TData extends RowData, TValue = unknown> {
    table: Table<TData>;
    column: Column<TData, TValue>;
    row: Row<TData>;
    cell: Cell<TData, TValue>;
    getValue: () => TValue;
    renderValue: () => TValue;
}
interface EventEmitter<TEventMap extends Record<string, any>> {
    on: <K extends keyof TEventMap>(event: K, handler: (payload: TEventMap[K]) => void) => () => void;
    off: <K extends keyof TEventMap>(event: K, handler: (payload: TEventMap[K]) => void) => void;
    emit: <K extends keyof TEventMap>(event: K, payload: TEventMap[K]) => void;
    removeAllListeners: (event?: keyof TEventMap) => void;
}
interface YableEventMap<TData extends RowData> {
    'cell:click': CellClickEvent<TData>;
    'cell:dblclick': CellClickEvent<TData>;
    'cell:contextmenu': CellClickEvent<TData>;
    'row:click': RowClickEvent<TData>;
    'row:dblclick': RowClickEvent<TData>;
    'row:contextmenu': RowClickEvent<TData>;
    'header:click': HeaderClickEvent<TData>;
    'header:contextmenu': HeaderClickEvent<TData>;
    'cell:edit:start': CellEditEvent<TData>;
    'cell:edit:commit': CellEditEvent<TData>;
    'cell:edit:cancel': CellEditEvent<TData>;
    'selection:change': SelectionChangeEvent<TData>;
    'sort:change': SortChangeEvent;
    'filter:change': FilterChangeEvent;
    'page:change': PageChangeEvent;
    'state:change': StateChangeEvent;
    undo: UndoRedoEvent;
    redo: UndoRedoEvent;
    'clipboard:copy': ClipboardEvent_;
    'clipboard:paste': ClipboardEvent_;
    'clipboard:cut': ClipboardEvent_;
    fill: FillEvent;
    'cell:flash': CellFlashEvent;
    'row:drag:start': RowDragEvent<TData>;
    'row:drag:end': RowDragEndEvent<TData>;
    'row:reorder': RowReorderEvent;
    'row:edit:start': RowEditEvent<TData>;
    'row:edit:commit': RowEditCommitEvent<TData>;
    'row:edit:cancel': RowEditEvent<TData>;
    'columns:remeasure': ColumnsRemeasureEvent;
}
interface ColumnsRemeasureEvent {
    /** Optional caller-supplied hint for why a re-measure was requested. */
    reason?: string;
}
interface CellClickEvent<TData extends RowData> {
    cell: Cell<TData, unknown>;
    row: Row<TData>;
    column: Column<TData, unknown>;
    originalEvent?: unknown;
}
interface RowClickEvent<TData extends RowData> {
    row: Row<TData>;
    cells: Cell<TData, unknown>[];
    originalEvent?: unknown;
}
interface HeaderClickEvent<TData extends RowData> {
    column: Column<TData, unknown>;
    header: Header<TData, unknown>;
    originalEvent?: unknown;
}
interface CellEditEvent<TData extends RowData> {
    cell: Cell<TData, unknown>;
    row: Row<TData>;
    column: Column<TData, unknown>;
    value: unknown;
    previousValue?: unknown;
}
interface SelectionChangeEvent<TData extends RowData> {
    selection: RowSelectionState;
    selectedRows: Row<TData>[];
}
interface SortChangeEvent {
    sorting: SortingState;
}
interface FilterChangeEvent {
    columnFilters: ColumnFiltersState;
    globalFilter: string;
}
interface PageChangeEvent {
    pagination: PaginationState;
}
interface StateChangeEvent {
    state: TableState;
    previousState: TableState;
}
interface UndoRedoEvent {
    action: UndoAction;
    state: UndoRedoState;
}
interface ClipboardEvent_ {
    text: string;
    cells: {
        rowId: string;
        columnId: string;
        value: unknown;
    }[];
}
interface FillEvent {
    sourceRange: {
        startRow: number;
        startCol: number;
        endRow: number;
        endCol: number;
    };
    targetRange: {
        startRow: number;
        startCol: number;
        endRow: number;
        endCol: number;
    };
    filledValues: {
        rowId: string;
        columnId: string;
        value: unknown;
    }[];
}
interface CellFlashEvent {
    columnId: string;
    rowId: string;
    direction: 'up' | 'down' | 'change';
    previousValue: unknown;
    newValue: unknown;
    timestamp: number;
}
interface ExportOptions {
    format?: 'csv' | 'json';
    allRows?: boolean;
    columns?: string[];
    includeHeaders?: boolean;
    delimiter?: string;
    fileName?: string;
}
interface RowDragEvent<TData extends RowData> {
    rowId: string;
    rowIndex: number;
    row: Row<TData>;
}
interface RowDragEndEvent<TData extends RowData> {
    rowId: string;
    row: Row<TData>;
    cancelled: boolean;
}
interface RowReorderEvent {
    fromIndex: number;
    toIndex: number;
    rowId: string;
}
interface RowEditEvent<TData extends RowData> {
    rowId: string;
    row: Row<TData>;
}
interface RowEditCommitEvent<TData extends RowData> {
    rowId: string;
    row: Row<TData>;
    values: Record<string, unknown>;
}
interface ColumnHelper<TData extends RowData> {
    accessor: <TAccessor extends DeepKeys<TData> | ((row: TData) => unknown), TValue extends TAccessor extends (...args: any) => infer R ? R : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never>(accessor: TAccessor, column: TAccessor extends (...args: any) => any ? Omit<AccessorFnColumnDef<TData, TValue>, 'accessorFn'> : Omit<AccessorKeyColumnDef<TData, TValue>, 'accessorKey'>) => ColumnDef<TData, TValue>;
    display: (column: DisplayColumnDef<TData>) => ColumnDef<TData, unknown>;
    group: (column: GroupColumnDef<TData>) => ColumnDef<TData, unknown>;
    /**
     * Normalize a heterogeneous column list into `ColumnDef<TData, unknown>[]`.
     *
     * `helper.accessor(...)` returns a `ColumnDef<TData, TValue>` with a concrete,
     * per-column `TValue`. Because `TValue` is invariant, an inline array of mixed
     * accessor columns (string, number, boolean, derived) infers as a union of
     * element types that does **not** assign to `ColumnDef<TData, unknown>[]`,
     * forcing an `as ColumnDef<TData, unknown>` cast on nearly every column. Wrap
     * the array in `helper.columns([...])` to erase the per-column `TValue` in one
     * place and get an array the table options accept directly.
     */
    columns: (columns: ReadonlyArray<ColumnDef<TData, any>>) => ColumnDef<TData, unknown>[];
}
declare module 'react' {
    interface CSSProperties {
        [key: string]: string | number | undefined;
    }
}

export type { ExportOptions as $, AccessorFnColumnDef as A, ColumnDefExtensions as B, CommitsSlice as C, DeepKeys as D, ColumnFilter as E, FilterFn as F, ColumnFiltersState as G, HeaderGroup as H, ColumnMeta as I, ColumnOrderState as J, KeyboardNavigationCell as K, ColumnPinningPosition as L, ColumnPinningState as M, ColumnSizingInfoState as N, OnCommitFn as O, ColumnSizingState as P, ColumnSort as Q, RowData as R, SortingFn as S, TableOptions as T, Updater as U, ColumnsRemeasureEvent as V, CommitResult as W, DisplayColumnDef as X, EditingState as Y, EventEmitter as Z, ExpandedState as _, CellPatch as a, FillHandleState as a0, FilterChangeEvent as a1, FilterFnOption as a2, FilterMeta as a3, FormulaState as a4, GroupColumnDef as a5, GroupingState as a6, HeaderClickEvent as a7, HeaderContext as a8, KeyboardNavigationDirection as a9, UndoAction as aA, UndoRedoState as aB, VisibilityState as aC, YableEventMap as aD, KeyboardNavigationState as aa, OnChangeFn as ab, PageChangeEvent as ac, PaginationState as ad, PivotConfig as ae, PivotState as af, RowClickEvent as ag, RowDragEndEvent as ah, RowDragEvent as ai, RowDragState as aj, RowEditCommitEvent as ak, RowEditEvent as al, RowModel as am, RowPinningPosition as an, RowPinningState as ao, RowReorderEvent as ap, RowSelectionState as aq, SelectionChangeEvent as ar, SortChangeEvent as as, SortDirection as at, SortingFnOption as au, SortingState as av, StateChangeEvent as aw, TableFeature as ax, TableOptionsResolved as ay, TableState as az, CommitRecord as b, Table as c, ColumnDef as d, Column as e, Row as f, Cell as g, Header as h, DeepValue as i, ColumnHelper as j, KeyboardNavigationAction as k, AccessorKeyColumnDef as l, AggregationFn as m, AggregationFnOption as n, CellClickEvent as o, CellContext as p, CellEditConfig as q, CellEditEvent as r, CellEditRenderProps as s, CellEditType as t, CellFlashEvent as u, CellRange as v, CellRangeSelectionState as w, CellStatus as x, ClipboardOptions as y, ColumnDefBase as z };