@tanstack/table-core 8.5.19 → 8.5.20

package/build/types/index.d.ts

@@ -9,17 +9,17 @@
  * @license MIT
  */
 declare type VisibilityState = Record<string, boolean>;
-declare type VisibilityTableState = {
+interface VisibilityTableState {
     columnVisibility: VisibilityState;
-};
-declare type VisibilityOptions = {
+}
+interface VisibilityOptions {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;
-};
-declare type VisibilityDefaultOptions = {
+}
+interface VisibilityDefaultOptions {
     onColumnVisibilityChange: OnChangeFn<VisibilityState>;
-};
-declare type VisibilityInstance<TData extends RowData> = {
+}
+interface VisibilityInstance<TData extends RowData> {
     getVisibleFlatColumns: () => Column<TData, unknown>[];
     getVisibleLeafColumns: () => Column<TData, unknown>[];
     getLeftVisibleLeafColumns: () => Column<TData, unknown>[];
@@ -31,89 +31,89 @@ declare type VisibilityInstance<TData extends RowData> = {
     getIsAllColumnsVisible: () => boolean;
     getIsSomeColumnsVisible: () => boolean;
     getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
-};
-declare type VisibilityColumnDef = {
+}
+interface VisibilityColumnDef {
     enableHiding?: boolean;
-};
-declare type VisibilityRow<TData extends RowData> = {
+}
+interface VisibilityRow<TData extends RowData> {
     _getAllVisibleCells: () => Cell<TData, unknown>[];
     getVisibleCells: () => Cell<TData, unknown>[];
-};
-declare type VisibilityColumn = {
+}
+interface VisibilityColumn {
     getCanHide: () => boolean;
     getIsVisible: () => boolean;
     toggleVisibility: (value?: boolean) => void;
     getToggleVisibilityHandler: () => (event: unknown) => void;
-};
+}
 declare const Visibility: TableFeature;
 
-declare type ColumnOrderTableState = {
+interface ColumnOrderTableState {
     columnOrder: ColumnOrderState;
-};
+}
 declare type ColumnOrderState = string[];
-declare type ColumnOrderOptions = {
+interface ColumnOrderOptions {
     onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
-};
-declare type ColumnOrderDefaultOptions = {
+}
+interface ColumnOrderDefaultOptions {
     onColumnOrderChange: OnChangeFn<ColumnOrderState>;
-};
-declare type ColumnOrderInstance<TData extends RowData> = {
+}
+interface ColumnOrderInstance<TData extends RowData> {
     setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
     resetColumnOrder: (defaultState?: boolean) => void;
     _getOrderColumnsFn: () => (columns: Column<TData, unknown>[]) => Column<TData, unknown>[];
-};
+}
 declare const Ordering: TableFeature;
 
 declare type ColumnPinningPosition = false | 'left' | 'right';
-declare type ColumnPinningState = {
+interface ColumnPinningState {
     left?: string[];
     right?: string[];
-};
-declare type ColumnPinningTableState = {
+}
+interface ColumnPinningTableState {
     columnPinning: ColumnPinningState;
-};
-declare type ColumnPinningOptions = {
+}
+interface ColumnPinningOptions {
     onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
     enablePinning?: boolean;
-};
-declare type ColumnPinningDefaultOptions = {
+}
+interface ColumnPinningDefaultOptions {
     onColumnPinningChange: OnChangeFn<ColumnPinningState>;
-};
-declare type ColumnPinningColumnDef = {
+}
+interface ColumnPinningColumnDef {
     enablePinning?: boolean;
-};
-declare type ColumnPinningColumn = {
+}
+interface ColumnPinningColumn {
     getCanPin: () => boolean;
     getPinnedIndex: () => number;
     getIsPinned: () => ColumnPinningPosition;
     pin: (position: ColumnPinningPosition) => void;
-};
-declare type ColumnPinningRow<TData extends RowData> = {
+}
+interface ColumnPinningRow<TData extends RowData> {
     getLeftVisibleCells: () => Cell<TData, unknown>[];
     getCenterVisibleCells: () => Cell<TData, unknown>[];
     getRightVisibleCells: () => Cell<TData, unknown>[];
-};
-declare type ColumnPinningInstance<TData extends RowData> = {
+}
+interface ColumnPinningInstance<TData extends RowData> {
     setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
     resetColumnPinning: (defaultState?: boolean) => void;
     getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
     getLeftLeafColumns: () => Column<TData, unknown>[];
     getRightLeafColumns: () => Column<TData, unknown>[];
     getCenterLeafColumns: () => Column<TData, unknown>[];
-};
+}
 declare const Pinning: TableFeature;
 
-declare type CoreHeaderGroup<TData extends RowData> = {
+interface CoreHeaderGroup<TData extends RowData> {
     id: string;
     depth: number;
     headers: Header<TData, unknown>[];
-};
-declare type HeaderContext<TData, TValue> = {
+}
+interface HeaderContext<TData, TValue> {
     table: Table<TData>;
     header: Header<TData, TValue>;
     column: Column<TData, TValue>;
-};
-declare type CoreHeader<TData extends RowData, TValue> = {
+}
+interface CoreHeader<TData extends RowData, TValue> {
     id: string;
     index: number;
     depth: number;
@@ -126,8 +126,8 @@ declare type CoreHeader<TData extends RowData, TValue> = {
     isPlaceholder: boolean;
     placeholderId?: string;
     getContext: () => HeaderContext<TData, TValue>;
-};
-declare type HeadersInstance<TData extends RowData> = {
+}
+interface HeadersInstance<TData extends RowData> {
     getHeaderGroups: () => HeaderGroup<TData>[];
     getLeftHeaderGroups: () => HeaderGroup<TData>[];
     getCenterHeaderGroups: () => HeaderGroup<TData>[];
@@ -144,7 +144,7 @@ declare type HeadersInstance<TData extends RowData> = {
     getLeftLeafHeaders: () => Header<TData, unknown>[];
     getCenterLeafHeaders: () => Header<TData, unknown>[];
     getRightLeafHeaders: () => Header<TData, unknown>[];
-};
+}
 declare const Headers: TableFeature;
 declare function buildHeaderGroups<TData extends RowData>(allColumns: Column<TData, unknown>[], columnsToGroup: Column<TData, unknown>[], table: Table<TData>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TData>[];
 
@@ -161,35 +161,35 @@ declare const filterFns: {
 };
 declare type BuiltInFilterFn = keyof typeof filterFns;
 
-declare type FiltersTableState = {
+interface FiltersTableState {
     columnFilters: ColumnFiltersState;
     globalFilter: any;
-};
+}
 declare type ColumnFiltersState = ColumnFilter[];
-declare type ColumnFilter = {
+interface ColumnFilter {
     id: string;
     value: unknown;
-};
-declare type ResolvedColumnFilter<TData extends RowData> = {
+}
+interface ResolvedColumnFilter<TData extends RowData> {
     id: string;
     resolvedValue: unknown;
     filterFn: FilterFn<TData>;
-};
-declare type FilterFn<TData extends RowData> = {
+}
+interface FilterFn<TData extends RowData> {
     (row: Row<TData>, columnId: string, filterValue: any, addMeta: (meta: FilterMeta) => void): boolean;
     resolveFilterValue?: TransformFilterValueFn<TData>;
     autoRemove?: ColumnFilterAutoRemoveTestFn<TData>;
-};
+}
 declare type TransformFilterValueFn<TData extends RowData> = (value: any, column?: Column<TData, unknown>) => unknown;
 declare type ColumnFilterAutoRemoveTestFn<TData extends RowData> = (value: any, column?: Column<TData, unknown>) => boolean;
 declare type CustomFilterFns<TData extends RowData> = Record<string, FilterFn<TData>>;
 declare type FilterFnOption<TData extends RowData> = 'auto' | BuiltInFilterFn | keyof FilterFns | FilterFn<TData>;
-declare type FiltersColumnDef<TData extends RowData> = {
+interface FiltersColumnDef<TData extends RowData> {
     filterFn?: FilterFnOption<TData>;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
-};
-declare type FiltersColumn<TData extends RowData> = {
+}
+interface FiltersColumn<TData extends RowData> {
     getAutoFilterFn: () => FilterFn<TData> | undefined;
     getFilterFn: () => FilterFn<TData> | undefined;
     setFilterValue: (updater: Updater<any>) => void;
@@ -204,12 +204,12 @@ declare type FiltersColumn<TData extends RowData> = {
     _getFacetedUniqueValues?: () => Map<any, number>;
     getFacetedMinMaxValues: () => undefined | [number, number];
     _getFacetedMinMaxValues?: () => undefined | [number, number];
-};
-declare type FiltersRow<TData extends RowData> = {
+}
+interface FiltersRow<TData extends RowData> {
     columnFilters: Record<string, boolean>;
     columnFiltersMeta: Record<string, FilterMeta>;
-};
-declare type FiltersOptions<TData extends RowData> = {
+}
+interface FiltersOptionsBase<TData extends RowData> {
     enableFilters?: boolean;
     manualFiltering?: boolean;
     filterFromLeafRows?: boolean;
@@ -223,12 +223,15 @@ declare type FiltersOptions<TData extends RowData> = {
     getFacetedRowModel?: (table: Table<TData>, columnId: string) => () => RowModel<TData>;
     getFacetedUniqueValues?: (table: Table<TData>, columnId: string) => () => Map<any, number>;
     getFacetedMinMaxValues?: (table: Table<TData>, columnId: string) => () => undefined | [number, number];
-} & (keyof FilterFns extends never ? {
+}
+declare type ResolvedFilterFns = keyof FilterFns extends never ? {
     filterFns?: Record<string, FilterFn<any>>;
 } : {
     filterFns: Record<keyof FilterFns, FilterFn<any>>;
-});
-declare type FiltersInstance<TData extends RowData> = {
+};
+interface FiltersOptions<TData extends RowData> extends FiltersOptionsBase<TData>, ResolvedFilterFns {
+}
+interface FiltersInstance<TData extends RowData> {
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
     resetColumnFilters: (defaultState?: boolean) => void;
     getPreFilteredRowModel: () => RowModel<TData>;
@@ -244,7 +247,7 @@ declare type FiltersInstance<TData extends RowData> = {
     _getGlobalFacetedUniqueValues?: () => Map<any, number>;
     getGlobalFacetedMinMaxValues: () => undefined | [number, number];
     _getGlobalFacetedMinMaxValues?: () => undefined | [number, number];
-};
+}
 declare const Filters: TableFeature;
 declare function shouldAutoRemoveFilter<TData extends RowData>(filterFn?: FilterFn<TData>, value?: any, column?: Column<TData, unknown>): boolean;
 
@@ -260,28 +263,28 @@ declare const sortingFns: {
 declare type BuiltInSortingFn = keyof typeof sortingFns;
 
 declare type SortDirection = 'asc' | 'desc';
-declare type ColumnSort = {
+interface ColumnSort {
     id: string;
     desc: boolean;
-};
+}
 declare type SortingState = ColumnSort[];
-declare type SortingTableState = {
+interface SortingTableState {
     sorting: SortingState;
-};
-declare type SortingFn<TData extends RowData> = {
+}
+interface SortingFn<TData extends RowData> {
     (rowA: Row<TData>, rowB: Row<TData>, columnId: string): number;
-};
+}
 declare type CustomSortingFns<TData extends RowData> = Record<string, SortingFn<TData>>;
 declare type SortingFnOption<TData extends RowData> = 'auto' | keyof SortingFns | BuiltInSortingFn | SortingFn<TData>;
-declare type SortingColumnDef<TData extends RowData> = {
+interface SortingColumnDef<TData extends RowData> {
     sortingFn?: SortingFnOption<TData>;
     sortDescFirst?: boolean;
     enableSorting?: boolean;
     enableMultiSort?: boolean;
     invertSorting?: boolean;
     sortUndefined?: false | -1 | 1;
-};
-declare type SortingColumn<TData extends RowData> = {
+}
+interface SortingColumn<TData extends RowData> {
     getAutoSortingFn: () => SortingFn<TData>;
     getAutoSortDir: () => SortDirection;
     getSortingFn: () => SortingFn<TData>;
@@ -294,8 +297,8 @@ declare type SortingColumn<TData extends RowData> = {
     clearSorting: () => void;
     toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
     getToggleSortingHandler: () => undefined | ((event: unknown) => void);
-};
-declare type SortingOptions<TData extends RowData> = {
+}
+interface SortingOptionsBase {
     manualSorting?: boolean;
     onSortingChange?: OnChangeFn<SortingState>;
     enableSorting?: boolean;
@@ -306,18 +309,21 @@ declare type SortingOptions<TData extends RowData> = {
     getSortedRowModel?: (table: Table<any>) => () => RowModel<any>;
     maxMultiSortColCount?: number;
     isMultiSortEvent?: (e: unknown) => boolean;
-} & (keyof SortingFns extends never ? {
+}
+declare type ResolvedSortingFns = keyof SortingFns extends never ? {
     sortingFns?: Record<string, SortingFn<any>>;
 } : {
     sortingFns: Record<keyof SortingFns, SortingFn<any>>;
-});
-declare type SortingInstance<TData extends RowData> = {
+};
+interface SortingOptions<TData extends RowData> extends SortingOptionsBase, ResolvedSortingFns {
+}
+interface SortingInstance<TData extends RowData> {
     setSorting: (updater: Updater<SortingState>) => void;
     resetSorting: (defaultState?: boolean) => void;
     getPreSortedRowModel: () => RowModel<TData>;
     getSortedRowModel: () => RowModel<TData>;
     _getSortedRowModel?: () => RowModel<TData>;
-};
+}
 declare const Sorting: TableFeature;
 
 declare const aggregationFns: {
@@ -334,18 +340,18 @@ declare const aggregationFns: {
 declare type BuiltInAggregationFn = keyof typeof aggregationFns;
 
 declare type GroupingState = string[];
-declare type GroupingTableState = {
+interface GroupingTableState {
     grouping: GroupingState;
-};
+}
 declare type AggregationFn<TData extends RowData> = (columnId: string, leafRows: Row<TData>[], childRows: Row<TData>[]) => any;
 declare type CustomAggregationFns = Record<string, AggregationFn<any>>;
 declare type AggregationFnOption<TData extends RowData> = 'auto' | keyof AggregationFns | BuiltInAggregationFn | AggregationFn<TData>;
-declare type GroupingColumnDef<TData extends RowData, TValue> = {
+interface GroupingColumnDef<TData extends RowData, TValue> {
     aggregationFn?: AggregationFnOption<TData>;
     aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TData, TValue>['getContext']>>;
     enableGrouping?: boolean;
-};
-declare type GroupingColumn<TData extends RowData> = {
+}
+interface GroupingColumn<TData extends RowData> {
     getCanGroup: () => boolean;
     getIsGrouped: () => boolean;
     getGroupedIndex: () => number;
@@ -353,56 +359,59 @@ declare type GroupingColumn<TData extends RowData> = {
     getToggleGroupingHandler: () => () => void;
     getAutoAggregationFn: () => AggregationFn<TData> | undefined;
     getAggregationFn: () => AggregationFn<TData> | undefined;
-};
-declare type GroupingRow = {
+}
+interface GroupingRow {
     groupingColumnId?: string;
     groupingValue?: unknown;
     getIsGrouped: () => boolean;
     _groupingValuesCache: Record<string, any>;
-};
-declare type GroupingCell = {
+}
+interface GroupingCell {
     getIsGrouped: () => boolean;
     getIsPlaceholder: () => boolean;
     getIsAggregated: () => boolean;
-};
-declare type ColumnDefaultOptions = {
+}
+interface ColumnDefaultOptions {
     onGroupingChange: OnChangeFn<GroupingState>;
     enableGrouping: boolean;
-};
-declare type GroupingOptions = {
+}
+interface GroupingOptionsBase {
     manualGrouping?: boolean;
     onGroupingChange?: OnChangeFn<GroupingState>;
     enableGrouping?: boolean;
     getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>;
     groupedColumnMode?: false | 'reorder' | 'remove';
-} & (keyof AggregationFns extends never ? {
+}
+declare type ResolvedAggregationFns = keyof AggregationFns extends never ? {
     aggregationFns?: Record<string, AggregationFn<any>>;
 } : {
     aggregationFns: Record<keyof AggregationFns, AggregationFn<any>>;
-});
+};
+interface GroupingOptions extends GroupingOptionsBase, ResolvedAggregationFns {
+}
 declare type GroupingColumnMode = false | 'reorder' | 'remove';
-declare type GroupingInstance<TData extends RowData> = {
+interface GroupingInstance<TData extends RowData> {
     setGrouping: (updater: Updater<GroupingState>) => void;
     resetGrouping: (defaultState?: boolean) => void;
     getPreGroupedRowModel: () => RowModel<TData>;
     getGroupedRowModel: () => RowModel<TData>;
     _getGroupedRowModel?: () => RowModel<TData>;
-};
+}
 declare const Grouping: TableFeature;
 declare function orderColumns<TData extends RowData>(leafColumns: Column<TData, unknown>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TData, unknown>[];
 
 declare type ExpandedStateList = Record<string, boolean>;
 declare type ExpandedState = true | Record<string, boolean>;
-declare type ExpandedTableState = {
+interface ExpandedTableState {
     expanded: ExpandedState;
-};
-declare type ExpandedRow = {
+}
+interface ExpandedRow {
     toggleExpanded: (expanded?: boolean) => void;
     getIsExpanded: () => boolean;
     getCanExpand: () => boolean;
     getToggleExpandedHandler: () => () => void;
-};
-declare type ExpandedOptions<TData extends RowData> = {
+}
+interface ExpandedOptions<TData extends RowData> {
     manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
@@ -411,8 +420,8 @@ declare type ExpandedOptions<TData extends RowData> = {
     getIsRowExpanded?: (row: Row<TData>) => boolean;
     getRowCanExpand?: (row: Row<TData>) => boolean;
     paginateExpandedRows?: boolean;
-};
-declare type ExpandedInstance<TData extends RowData> = {
+}
+interface ExpandedInstance<TData extends RowData> {
     _autoResetExpanded: () => void;
     setExpanded: (updater: Updater<ExpandedState>) => void;
     toggleAllRowsExpanded: (expanded?: boolean) => void;
@@ -425,35 +434,35 @@ declare type ExpandedInstance<TData extends RowData> = {
     getExpandedRowModel: () => RowModel<TData>;
     _getExpandedRowModel?: () => RowModel<TData>;
     getPreExpandedRowModel: () => RowModel<TData>;
-};
+}
 declare const Expanding: TableFeature;
 
-declare type ColumnSizingTableState = {
+interface ColumnSizingTableState {
     columnSizing: ColumnSizingState;
     columnSizingInfo: ColumnSizingInfoState;
-};
+}
 declare type ColumnSizingState = Record<string, number>;
-declare type ColumnSizingInfoState = {
+interface ColumnSizingInfoState {
     startOffset: null | number;
     startSize: null | number;
     deltaOffset: null | number;
     deltaPercentage: null | number;
     isResizingColumn: false | string;
     columnSizingStart: [string, number][];
-};
+}
 declare type ColumnResizeMode = 'onChange' | 'onEnd';
-declare type ColumnSizingOptions = {
+interface ColumnSizingOptions {
     enableColumnResizing?: boolean;
     columnResizeMode?: ColumnResizeMode;
     onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
-};
-declare type ColumnSizingDefaultOptions = {
+}
+interface ColumnSizingDefaultOptions {
     columnResizeMode: ColumnResizeMode;
     onColumnSizingChange: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
-};
-declare type ColumnSizingInstance = {
+}
+interface ColumnSizingInstance {
     setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
     setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
     resetColumnSizing: (defaultState?: boolean) => void;
@@ -462,25 +471,25 @@ declare type ColumnSizingInstance = {
     getLeftTotalSize: () => number;
     getCenterTotalSize: () => number;
     getRightTotalSize: () => number;
-};
-declare type ColumnSizingColumnDef = {
+}
+interface ColumnSizingColumnDef {
     enableResizing?: boolean;
     size?: number;
     minSize?: number;
     maxSize?: number;
-};
-declare type ColumnSizingColumn = {
+}
+interface ColumnSizingColumn {
     getSize: () => number;
     getStart: (position?: ColumnPinningPosition) => number;
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
     resetSize: () => void;
-};
-declare type ColumnSizingHeader = {
+}
+interface ColumnSizingHeader {
     getSize: () => number;
     getStart: (position?: ColumnPinningPosition) => number;
     getResizeHandler: () => (event: unknown) => void;
-};
+}
 declare const defaultColumnSizing: {
     size: number;
     minSize: number;
@@ -489,27 +498,27 @@ declare const defaultColumnSizing: {
 declare const ColumnSizing: TableFeature;
 declare function passiveEventSupported(): boolean;
 
-declare type PaginationState = {
+interface PaginationState {
     pageIndex: number;
     pageSize: number;
-};
-declare type PaginationTableState = {
+}
+interface PaginationTableState {
     pagination: PaginationState;
-};
-declare type PaginationInitialTableState = {
+}
+interface PaginationInitialTableState {
     pagination?: Partial<PaginationState>;
-};
-declare type PaginationOptions = {
+}
+interface PaginationOptions {
     pageCount?: number;
     manualPagination?: boolean;
     onPaginationChange?: OnChangeFn<PaginationState>;
     autoResetPageIndex?: boolean;
     getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>;
-};
-declare type PaginationDefaultOptions = {
+}
+interface PaginationDefaultOptions {
     onPaginationChange: OnChangeFn<PaginationState>;
-};
-declare type PaginationInstance<TData extends RowData> = {
+}
+interface PaginationInstance<TData extends RowData> {
     _autoResetPageIndex: () => void;
     setPagination: (updater: Updater<PaginationState>) => void;
     resetPagination: (defaultState?: boolean) => void;
@@ -527,20 +536,20 @@ declare type PaginationInstance<TData extends RowData> = {
     getPaginationRowModel: () => RowModel<TData>;
     _getPaginationRowModel?: () => RowModel<TData>;
     getPageCount: () => number;
-};
+}
 declare const Pagination: TableFeature;
 
 declare type RowSelectionState = Record<string, boolean>;
-declare type RowSelectionTableState = {
+interface RowSelectionTableState {
     rowSelection: RowSelectionState;
-};
-declare type RowSelectionOptions<TData extends RowData> = {
+}
+interface RowSelectionOptions<TData extends RowData> {
     enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
     enableMultiRowSelection?: boolean | ((row: Row<TData>) => boolean);
     enableSubRowSelection?: boolean | ((row: Row<TData>) => boolean);
     onRowSelectionChange?: OnChangeFn<RowSelectionState>;
-};
-declare type RowSelectionRow = {
+}
+interface RowSelectionRow {
     getIsSelected: () => boolean;
     getIsSomeSelected: () => boolean;
     getIsAllSubRowsSelected: () => boolean;
@@ -549,8 +558,8 @@ declare type RowSelectionRow = {
     getCanSelectSubRows: () => boolean;
     toggleSelected: (value?: boolean) => void;
     getToggleSelectedHandler: () => (event: unknown) => void;
-};
-declare type RowSelectionInstance<TData extends RowData> = {
+}
+interface RowSelectionInstance<TData extends RowData> {
     getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
     getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
     setRowSelection: (updater: Updater<RowSelectionState>) => void;
@@ -565,13 +574,13 @@ declare type RowSelectionInstance<TData extends RowData> = {
     getSelectedRowModel: () => RowModel<TData>;
     getFilteredSelectedRowModel: () => RowModel<TData>;
     getGroupedSelectedRowModel: () => RowModel<TData>;
-};
+}
 declare const RowSelection: TableFeature;
 declare function selectRowsFn<TData extends RowData>(table: Table<TData>, rowModel: RowModel<TData>): RowModel<TData>;
 declare function isRowSelected<TData extends RowData>(row: Row<TData>, selection: Record<string, boolean>): boolean;
 declare function isSubRowSelected<TData extends RowData>(row: Row<TData>, selection: Record<string, boolean>, table: Table<TData>): boolean | 'some' | 'all';
 
-declare type CoreRow<TData extends RowData> = {
+interface CoreRow<TData extends RowData> {
     id: string;
     index: number;
     original: TData;
@@ -586,28 +595,28 @@ declare type CoreRow<TData extends RowData> = {
     originalSubRows?: TData[];
     getAllCells: () => Cell<TData, unknown>[];
     _getAllCellsByColumnId: () => Record<string, Cell<TData, unknown>>;
-};
+}
 declare const createRow: <TData extends unknown>(table: Table<TData>, id: string, original: TData, rowIndex: number, depth: number, subRows?: Row<TData>[] | undefined) => Row<TData>;
 
-declare type CellContext<TData extends RowData, TValue> = {
+interface CellContext<TData extends RowData, TValue> {
     table: Table<TData>;
     column: Column<TData, TValue>;
     row: Row<TData>;
     cell: Cell<TData, TValue>;
     getValue: Getter<TValue>;
     renderValue: Getter<TValue | null>;
-};
-declare type CoreCell<TData extends RowData, TValue> = {
+}
+interface CoreCell<TData extends RowData, TValue> {
     id: string;
     getValue: CellContext<TData, TValue>['getValue'];
     renderValue: CellContext<TData, TValue>['renderValue'];
     row: Row<TData>;
     column: Column<TData, TValue>;
     getContext: () => CellContext<TData, TValue>;
-};
+}
 declare function createCell<TData extends RowData, TValue>(table: Table<TData>, row: Row<TData>, column: Column<TData, TValue>, columnId: string): Cell<TData, TValue>;
 
-declare type CoreColumn<TData extends RowData, TValue> = {
+interface CoreColumn<TData extends RowData, TValue> {
     id: string;
     depth: number;
     accessorFn?: AccessorFn<TData, TValue>;
@@ -616,7 +625,7 @@ declare type CoreColumn<TData extends RowData, TValue> = {
     parent?: Column<TData, TValue>;
     getFlatColumns: () => Column<TData, TValue>[];
     getLeafColumns: () => Column<TData, TValue>[];
-};
+}
 declare function createColumn<TData extends RowData, TValue>(table: Table<TData>, columnDef: ColumnDef<TData, TValue>, depth: number, parent?: Column<TData, TValue>): Column<TData, TValue>;
 
 interface TableMeta<TData extends RowData> {
@@ -635,78 +644,120 @@ declare type Updater<T> = T | ((old: T) => T);
 declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
 declare type RowData = unknown | object | any[];
 declare type AnyRender = (Comp: any, props: any) => any;
-declare type Table<TData extends RowData> = CoreInstance<TData> & HeadersInstance<TData> & VisibilityInstance<TData> & ColumnOrderInstance<TData> & ColumnPinningInstance<TData> & FiltersInstance<TData> & SortingInstance<TData> & GroupingInstance<TData> & ColumnSizingInstance & ExpandedInstance<TData> & PaginationInstance<TData> & RowSelectionInstance<TData>;
-declare type TableOptionsResolved<TData extends RowData> = CoreOptions<TData> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TData> & SortingOptions<TData> & GroupingOptions & ExpandedOptions<TData> & ColumnSizingOptions & PaginationOptions & RowSelectionOptions<TData>;
-declare type TableOptions<TData extends RowData> = PartialKeys<TableOptionsResolved<TData>, 'state' | 'onStateChange' | 'renderFallbackValue'>;
-declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
-declare type InitialTableState = Partial<CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationInitialTableState & RowSelectionTableState>;
-declare type Row<TData extends RowData> = CoreRow<TData> & VisibilityRow<TData> & ColumnPinningRow<TData> & FiltersRow<TData> & GroupingRow & RowSelectionRow & ExpandedRow;
-declare type RowModel<TData extends RowData> = {
+interface Table<TData extends RowData> extends CoreInstance<TData>, HeadersInstance<TData>, VisibilityInstance<TData>, ColumnOrderInstance<TData>, ColumnPinningInstance<TData>, FiltersInstance<TData>, SortingInstance<TData>, GroupingInstance<TData>, ColumnSizingInstance, ExpandedInstance<TData>, PaginationInstance<TData>, RowSelectionInstance<TData> {
+}
+interface FeatureOptions<TData extends RowData> extends VisibilityOptions, ColumnOrderOptions, ColumnPinningOptions, FiltersOptions<TData>, SortingOptions<TData>, GroupingOptions, ExpandedOptions<TData>, ColumnSizingOptions, PaginationOptions, RowSelectionOptions<TData> {
+}
+declare type TableOptionsResolved<TData extends RowData> = CoreOptions<TData> & FeatureOptions<TData>;
+interface TableOptions<TData extends RowData> extends PartialKeys<TableOptionsResolved<TData>, 'state' | 'onStateChange' | 'renderFallbackValue'> {
+}
+interface TableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, FiltersTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationTableState, RowSelectionTableState {
+}
+interface CompleteInitialTableState extends CoreTableState, VisibilityTableState, ColumnOrderTableState, ColumnPinningTableState, FiltersTableState, SortingTableState, ExpandedTableState, GroupingTableState, ColumnSizingTableState, PaginationInitialTableState, RowSelectionTableState {
+}
+interface InitialTableState extends Partial<CompleteInitialTableState> {
+}
+interface Row<TData extends RowData> extends CoreRow<TData>, VisibilityRow<TData>, ColumnPinningRow<TData>, FiltersRow<TData>, GroupingRow, RowSelectionRow, ExpandedRow {
+}
+interface RowModel<TData extends RowData> {
     rows: Row<TData>[];
     flatRows: Row<TData>[];
     rowsById: Record<string, Row<TData>>;
-};
+}
 declare type AccessorFn<TData extends RowData, TValue = unknown> = (originalRow: TData, index: number) => TValue;
 declare type ColumnDefTemplate<TProps extends object> = string | ((props: TProps) => any);
 declare type StringOrTemplateHeader<TData, TValue> = string | ColumnDefTemplate<HeaderContext<TData, TValue>>;
-declare type StringHeaderIdentifier = {
+interface StringHeaderIdentifier {
     header: string;
     id?: string;
-};
-declare type IdIdentifier<TData extends RowData, TValue> = {
+}
+interface IdIdentifier<TData extends RowData, TValue> {
     id: string;
     header?: StringOrTemplateHeader<TData, TValue>;
-};
+}
 declare type ColumnIdentifiers<TData extends RowData, TValue> = IdIdentifier<TData, TValue> | StringHeaderIdentifier;
-declare type ColumnDefBase<TData extends RowData, TValue = unknown> = {
+interface ColumnDefExtensions<TData extends RowData, TValue = unknown> extends VisibilityColumnDef, ColumnPinningColumnDef, FiltersColumnDef<TData>, SortingColumnDef<TData>, GroupingColumnDef<TData, TValue>, ColumnSizingColumnDef {
+}
+interface ColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefExtensions<TData, TValue> {
     getUniqueValues?: AccessorFn<TData, unknown[]>;
     footer?: ColumnDefTemplate<HeaderContext<TData, TValue>>;
     cell?: ColumnDefTemplate<CellContext<TData, TValue>>;
     meta?: ColumnMeta<TData, TValue>;
-} & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TData> & SortingColumnDef<TData> & GroupingColumnDef<TData, TValue> & ColumnSizingColumnDef;
-declare type IdentifiedColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & {
+}
+interface IdentifiedColumnDef<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
     id?: string;
     header?: StringOrTemplateHeader<TData, TValue>;
-};
+}
 declare type DisplayColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
-declare type GroupColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue> & {
+interface GroupColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
     columns?: ColumnDef<TData, any>[];
-};
-declare type AccessorFnColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue> & {
+}
+declare type GroupColumnDef<TData extends RowData, TValue = unknown> = GroupColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
+interface AccessorFnColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
     accessorFn: AccessorFn<TData, TValue>;
-};
-declare type AccessorKeyColumnDef<TData extends RowData, TValue = unknown> = {
+}
+declare type AccessorFnColumnDef<TData extends RowData, TValue = unknown> = AccessorFnColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
+interface AccessorKeyColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
     id?: string;
-} & Partial<ColumnIdentifiers<TData, TValue>> & ColumnDefBase<TData, TValue> & {
     accessorKey: string | keyof TData;
-};
+}
+declare type AccessorKeyColumnDef<TData extends RowData, TValue = unknown> = AccessorKeyColumnDefBase<TData, TValue> & Partial<ColumnIdentifiers<TData, TValue>>;
 declare type AccessorColumnDef<TData extends RowData, TValue = unknown> = AccessorKeyColumnDef<TData, TValue> | AccessorFnColumnDef<TData, TValue>;
 declare type ColumnDef<TData extends RowData, TValue = unknown> = DisplayColumnDef<TData, TValue> | GroupColumnDef<TData, TValue> | AccessorColumnDef<TData, TValue>;
 declare type ColumnDefResolved<TData extends RowData, TValue = unknown> = Partial<UnionToIntersection<ColumnDef<TData, TValue>>> & {
     accessorKey?: string;
 };
-declare type Column<TData extends RowData, TValue = unknown> = CoreColumn<TData, TValue> & VisibilityColumn & ColumnPinningColumn & FiltersColumn<TData> & SortingColumn<TData> & GroupingColumn<TData> & ColumnSizingColumn;
-declare type Cell<TData extends RowData, TValue> = CoreCell<TData, TValue> & GroupingCell;
-declare type Header<TData extends RowData, TValue> = CoreHeader<TData, TValue> & ColumnSizingHeader;
-declare type HeaderGroup<TData extends RowData> = CoreHeaderGroup<TData>;
+interface Column<TData extends RowData, TValue = unknown> extends CoreColumn<TData, TValue>, VisibilityColumn, ColumnPinningColumn, FiltersColumn<TData>, SortingColumn<TData>, GroupingColumn<TData>, ColumnSizingColumn {
+}
+interface Cell<TData extends RowData, TValue> extends CoreCell<TData, TValue>, GroupingCell {
+}
+interface Header<TData extends RowData, TValue> extends CoreHeader<TData, TValue>, ColumnSizingHeader {
+}
+interface HeaderGroup<TData extends RowData> extends CoreHeaderGroup<TData> {
+}
 
-declare type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-declare type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+declare type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+declare type RequiredKeys<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
 declare type Overwrite<T, U extends {
     [TKey in keyof T]?: any;
 }> = Omit<T, keyof U> & U;
 declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
 declare type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
 declare type IsKnown<T, Y, N> = unknown extends T ? N : Y;
-declare type ComputeRange<N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : ComputeRange<N, [...Result, Result['length']]>;
-declare type Index40 = ComputeRange<40>[number];
-declare type IsTuple<T> = T extends readonly any[] & {
-    length: infer Length;
-} ? Length extends Index40 ? T : never : never;
-declare type AllowedIndexes<Tuple extends ReadonlyArray<any>, Keys extends number = never> = Tuple extends readonly [] ? Keys : Tuple extends readonly [infer _, ...infer Tail] ? AllowedIndexes<Tail, Keys | Tail['length']> : Keys;
-declare type DeepKeys<T> = unknown extends T ? keyof T : object extends T ? string : T extends readonly any[] & IsTuple<T> ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>> : T extends any[] ? never & 'Dynamic length array indexing is not supported' : T extends Date ? never : T extends object ? (keyof T & string) | DeepKeysPrefix<T, keyof T> : never;
-declare type DeepKeysPrefix<T, TPrefix> = TPrefix extends keyof T & (number | string) ? `${TPrefix}.${DeepKeys<T[TPrefix]> & string}` : never;
-declare type DeepValue<T, TProp> = T extends Record<string | number, any> ? TProp extends `${infer TBranch}.${infer TDeepProp}` ? DeepValue<T[TBranch], TDeepProp> : T[TProp & string] : never;
+declare type IndexableData = Record<string | number, any>;
+declare type DeepValue<T, TProp> = T extends IndexableData ? TProp extends `${infer TBranch}.${infer TDeepProp}` ? DeepValue<T[TBranch], TDeepProp> : TProp extends keyof T ? T[TProp] : never : never;
+declare type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
+declare type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    ...0[]
+];
+declare type ExplicitLeaves = Date | Number | BigInt | String | Set<unknown> | Map<unknown, unknown> | WeakSet<object> | WeakMap<object, unknown>;
+declare type DeepKeys<T, D extends number = 10> = [D] extends [never] ? never : T extends ExplicitLeaves ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, DeepKeys<T[K], Prev[D]>> : never;
+}[keyof T] : '';
 declare type NoInfer<T> = [T][T extends any ? 0 : never];
 declare type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>;
 declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
@@ -721,7 +772,7 @@ declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...
     onChange?: (result: TResult) => void;
 }): () => TResult;
 
-declare type TableFeature = {
+interface TableFeature {
     getDefaultOptions?: (table: any) => any;
     getInitialState?: (initialState?: InitialTableState) => any;
     createTable?: (table: any) => any;
@@ -730,9 +781,10 @@ declare type TableFeature = {
     createHeader?: (column: any, table: any) => any;
     createCell?: (cell: any, column: any, row: any, table: any) => any;
     createRow?: (row: any, table: any) => any;
-};
-declare type CoreTableState = {};
-declare type CoreOptions<TData extends RowData> = {
+}
+interface CoreTableState {
+}
+interface CoreOptions<TData extends RowData> {
     data: TData[];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
@@ -751,8 +803,8 @@ declare type CoreOptions<TData extends RowData> = {
     columns: ColumnDef<TData, any>[];
     defaultColumn?: Partial<ColumnDef<TData, unknown>>;
     renderFallbackValue: any;
-};
-declare type CoreInstance<TData extends RowData> = {
+}
+interface CoreInstance<TData extends RowData> {
     initialState: TableState;
     reset: () => void;
     options: RequiredKeys<TableOptionsResolved<TData>, 'state'>;
@@ -773,14 +825,16 @@ declare type CoreInstance<TData extends RowData> = {
     getAllFlatColumns: () => Column<TData, unknown>[];
     getAllLeafColumns: () => Column<TData, unknown>[];
     getColumn: (columnId: string) => Column<TData, unknown>;
-};
+}
 declare function createTable<TData extends RowData>(options: TableOptionsResolved<TData>): Table<TData>;
 
-declare type ColumnHelper<TData extends RowData> = {
-    accessor: <TAccessor extends AccessorFn<TData> | DeepKeys<TData>, TValue extends TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never>(accessor: TAccessor, column: TAccessor extends AccessorFn<TData> ? DisplayColumnDef<TData, TValue> : IdentifiedColumnDef<TData, TValue>) => ColumnDef<TData, TValue>;
-    display: (column: DisplayColumnDef<TData>) => ColumnDef<TData, unknown>;
-    group: (column: GroupColumnDef<TData>) => ColumnDef<TData, unknown>;
-};
+declare type AccessorType<TData, TAccessor> = TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : DeepValue<TData, TAccessor>;
+declare type Accessor<TData extends RowData> = <TAccessor extends AccessorFn<TData> | string, TValue extends AccessorType<TData, TAccessor>>(accessor: TAccessor, column: TAccessor extends AccessorFn<TData> ? DisplayColumnDef<TData, TValue> : IdentifiedColumnDef<TData, TValue>) => TValue extends never ? never : AccessorColumnDef<TData, AccessorType<TData, TAccessor>>;
+interface ColumnHelper<TData extends RowData> {
+    accessor: Accessor<TData>;
+    display: (column: DisplayColumnDef<TData>) => DisplayColumnDef<TData>;
+    group: (column: GroupColumnDef<TData>) => GroupColumnDef<TData>;
+}
 declare function createColumnHelper<TData extends RowData>(): ColumnHelper<TData>;
 
 declare function getCoreRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;