@tanstack/table-core 8.5.20 → 8.5.22

package/build/types/index.d.ts

@@ -9,17 +9,17 @@
  * @license MIT
  */
 declare type VisibilityState = Record<string, boolean>;
-interface VisibilityTableState {
+declare type VisibilityTableState = {
     columnVisibility: VisibilityState;
-}
-interface VisibilityOptions {
+};
+declare type VisibilityOptions = {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;
-}
-interface VisibilityDefaultOptions {
+};
+declare type VisibilityDefaultOptions = {
     onColumnVisibilityChange: OnChangeFn<VisibilityState>;
-}
-interface VisibilityInstance<TData extends RowData> {
+};
+declare type VisibilityInstance<TData extends RowData> = {
     getVisibleFlatColumns: () => Column<TData, unknown>[];
     getVisibleLeafColumns: () => Column<TData, unknown>[];
     getLeftVisibleLeafColumns: () => Column<TData, unknown>[];
@@ -31,89 +31,89 @@ interface VisibilityInstance<TData extends RowData> {
     getIsAllColumnsVisible: () => boolean;
     getIsSomeColumnsVisible: () => boolean;
     getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
-}
-interface VisibilityColumnDef {
+};
+declare type VisibilityColumnDef = {
     enableHiding?: boolean;
-}
-interface VisibilityRow<TData extends RowData> {
+};
+declare type VisibilityRow<TData extends RowData> = {
     _getAllVisibleCells: () => Cell<TData, unknown>[];
     getVisibleCells: () => Cell<TData, unknown>[];
-}
-interface VisibilityColumn {
+};
+declare type VisibilityColumn = {
     getCanHide: () => boolean;
     getIsVisible: () => boolean;
     toggleVisibility: (value?: boolean) => void;
     getToggleVisibilityHandler: () => (event: unknown) => void;
-}
+};
 declare const Visibility: TableFeature;
 
-interface ColumnOrderTableState {
+declare type ColumnOrderTableState = {
     columnOrder: ColumnOrderState;
-}
+};
 declare type ColumnOrderState = string[];
-interface ColumnOrderOptions {
+declare type ColumnOrderOptions = {
     onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
-}
-interface ColumnOrderDefaultOptions {
+};
+declare type ColumnOrderDefaultOptions = {
     onColumnOrderChange: OnChangeFn<ColumnOrderState>;
-}
-interface ColumnOrderInstance<TData extends RowData> {
+};
+declare type 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';
-interface ColumnPinningState {
+declare type ColumnPinningState = {
     left?: string[];
     right?: string[];
-}
-interface ColumnPinningTableState {
+};
+declare type ColumnPinningTableState = {
     columnPinning: ColumnPinningState;
-}
-interface ColumnPinningOptions {
+};
+declare type ColumnPinningOptions = {
     onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
     enablePinning?: boolean;
-}
-interface ColumnPinningDefaultOptions {
+};
+declare type ColumnPinningDefaultOptions = {
     onColumnPinningChange: OnChangeFn<ColumnPinningState>;
-}
-interface ColumnPinningColumnDef {
+};
+declare type ColumnPinningColumnDef = {
     enablePinning?: boolean;
-}
-interface ColumnPinningColumn {
+};
+declare type ColumnPinningColumn = {
     getCanPin: () => boolean;
     getPinnedIndex: () => number;
     getIsPinned: () => ColumnPinningPosition;
     pin: (position: ColumnPinningPosition) => void;
-}
-interface ColumnPinningRow<TData extends RowData> {
+};
+declare type ColumnPinningRow<TData extends RowData> = {
     getLeftVisibleCells: () => Cell<TData, unknown>[];
     getCenterVisibleCells: () => Cell<TData, unknown>[];
     getRightVisibleCells: () => Cell<TData, unknown>[];
-}
-interface ColumnPinningInstance<TData extends RowData> {
+};
+declare type 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;
 
-interface CoreHeaderGroup<TData extends RowData> {
+declare type CoreHeaderGroup<TData extends RowData> = {
     id: string;
     depth: number;
     headers: Header<TData, unknown>[];
-}
-interface HeaderContext<TData, TValue> {
+};
+declare type HeaderContext<TData, TValue> = {
     table: Table<TData>;
     header: Header<TData, TValue>;
     column: Column<TData, TValue>;
-}
-interface CoreHeader<TData extends RowData, TValue> {
+};
+declare type CoreHeader<TData extends RowData, TValue> = {
     id: string;
     index: number;
     depth: number;
@@ -126,8 +126,8 @@ interface CoreHeader<TData extends RowData, TValue> {
     isPlaceholder: boolean;
     placeholderId?: string;
     getContext: () => HeaderContext<TData, TValue>;
-}
-interface HeadersInstance<TData extends RowData> {
+};
+declare type HeadersInstance<TData extends RowData> = {
     getHeaderGroups: () => HeaderGroup<TData>[];
     getLeftHeaderGroups: () => HeaderGroup<TData>[];
     getCenterHeaderGroups: () => HeaderGroup<TData>[];
@@ -144,7 +144,7 @@ interface 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;
 
-interface FiltersTableState {
+declare type FiltersTableState = {
     columnFilters: ColumnFiltersState;
     globalFilter: any;
-}
+};
 declare type ColumnFiltersState = ColumnFilter[];
-interface ColumnFilter {
+declare type ColumnFilter = {
     id: string;
     value: unknown;
-}
-interface ResolvedColumnFilter<TData extends RowData> {
+};
+declare type ResolvedColumnFilter<TData extends RowData> = {
     id: string;
     resolvedValue: unknown;
     filterFn: FilterFn<TData>;
-}
-interface FilterFn<TData extends RowData> {
+};
+declare type 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>;
-interface FiltersColumnDef<TData extends RowData> {
+declare type FiltersColumnDef<TData extends RowData> = {
     filterFn?: FilterFnOption<TData>;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
-}
-interface FiltersColumn<TData extends RowData> {
+};
+declare type FiltersColumn<TData extends RowData> = {
     getAutoFilterFn: () => FilterFn<TData> | undefined;
     getFilterFn: () => FilterFn<TData> | undefined;
     setFilterValue: (updater: Updater<any>) => void;
@@ -204,12 +204,12 @@ interface FiltersColumn<TData extends RowData> {
     _getFacetedUniqueValues?: () => Map<any, number>;
     getFacetedMinMaxValues: () => undefined | [number, number];
     _getFacetedMinMaxValues?: () => undefined | [number, number];
-}
-interface FiltersRow<TData extends RowData> {
+};
+declare type FiltersRow<TData extends RowData> = {
     columnFilters: Record<string, boolean>;
     columnFiltersMeta: Record<string, FilterMeta>;
-}
-interface FiltersOptionsBase<TData extends RowData> {
+};
+declare type FiltersOptions<TData extends RowData> = {
     enableFilters?: boolean;
     manualFiltering?: boolean;
     filterFromLeafRows?: boolean;
@@ -223,15 +223,12 @@ interface FiltersOptionsBase<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];
-}
-declare type ResolvedFilterFns = keyof FilterFns extends never ? {
+} & (keyof FilterFns extends never ? {
     filterFns?: Record<string, FilterFn<any>>;
 } : {
     filterFns: Record<keyof FilterFns, FilterFn<any>>;
-};
-interface FiltersOptions<TData extends RowData> extends FiltersOptionsBase<TData>, ResolvedFilterFns {
-}
-interface FiltersInstance<TData extends RowData> {
+});
+declare type FiltersInstance<TData extends RowData> = {
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
     resetColumnFilters: (defaultState?: boolean) => void;
     getPreFilteredRowModel: () => RowModel<TData>;
@@ -247,7 +244,7 @@ interface 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;
 
@@ -263,28 +260,28 @@ declare const sortingFns: {
 declare type BuiltInSortingFn = keyof typeof sortingFns;
 
 declare type SortDirection = 'asc' | 'desc';
-interface ColumnSort {
+declare type ColumnSort = {
     id: string;
     desc: boolean;
-}
+};
 declare type SortingState = ColumnSort[];
-interface SortingTableState {
+declare type SortingTableState = {
     sorting: SortingState;
-}
-interface SortingFn<TData extends RowData> {
+};
+declare type 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>;
-interface SortingColumnDef<TData extends RowData> {
+declare type SortingColumnDef<TData extends RowData> = {
     sortingFn?: SortingFnOption<TData>;
     sortDescFirst?: boolean;
     enableSorting?: boolean;
     enableMultiSort?: boolean;
     invertSorting?: boolean;
     sortUndefined?: false | -1 | 1;
-}
-interface SortingColumn<TData extends RowData> {
+};
+declare type SortingColumn<TData extends RowData> = {
     getAutoSortingFn: () => SortingFn<TData>;
     getAutoSortDir: () => SortDirection;
     getSortingFn: () => SortingFn<TData>;
@@ -297,8 +294,8 @@ interface SortingColumn<TData extends RowData> {
     clearSorting: () => void;
     toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
     getToggleSortingHandler: () => undefined | ((event: unknown) => void);
-}
-interface SortingOptionsBase {
+};
+declare type SortingOptions<TData extends RowData> = {
     manualSorting?: boolean;
     onSortingChange?: OnChangeFn<SortingState>;
     enableSorting?: boolean;
@@ -309,21 +306,18 @@ interface SortingOptionsBase {
     getSortedRowModel?: (table: Table<any>) => () => RowModel<any>;
     maxMultiSortColCount?: number;
     isMultiSortEvent?: (e: unknown) => boolean;
-}
-declare type ResolvedSortingFns = keyof SortingFns extends never ? {
+} & (keyof SortingFns extends never ? {
     sortingFns?: Record<string, SortingFn<any>>;
 } : {
     sortingFns: Record<keyof SortingFns, SortingFn<any>>;
-};
-interface SortingOptions<TData extends RowData> extends SortingOptionsBase, ResolvedSortingFns {
-}
-interface SortingInstance<TData extends RowData> {
+});
+declare type 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: {
@@ -340,18 +334,18 @@ declare const aggregationFns: {
 declare type BuiltInAggregationFn = keyof typeof aggregationFns;
 
 declare type GroupingState = string[];
-interface GroupingTableState {
+declare type 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>;
-interface GroupingColumnDef<TData extends RowData, TValue> {
+declare type GroupingColumnDef<TData extends RowData, TValue> = {
     aggregationFn?: AggregationFnOption<TData>;
     aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TData, TValue>['getContext']>>;
     enableGrouping?: boolean;
-}
-interface GroupingColumn<TData extends RowData> {
+};
+declare type GroupingColumn<TData extends RowData> = {
     getCanGroup: () => boolean;
     getIsGrouped: () => boolean;
     getGroupedIndex: () => number;
@@ -359,59 +353,56 @@ interface GroupingColumn<TData extends RowData> {
     getToggleGroupingHandler: () => () => void;
     getAutoAggregationFn: () => AggregationFn<TData> | undefined;
     getAggregationFn: () => AggregationFn<TData> | undefined;
-}
-interface GroupingRow {
+};
+declare type GroupingRow = {
     groupingColumnId?: string;
     groupingValue?: unknown;
     getIsGrouped: () => boolean;
     _groupingValuesCache: Record<string, any>;
-}
-interface GroupingCell {
+};
+declare type GroupingCell = {
     getIsGrouped: () => boolean;
     getIsPlaceholder: () => boolean;
     getIsAggregated: () => boolean;
-}
-interface ColumnDefaultOptions {
+};
+declare type ColumnDefaultOptions = {
     onGroupingChange: OnChangeFn<GroupingState>;
     enableGrouping: boolean;
-}
-interface GroupingOptionsBase {
+};
+declare type GroupingOptions = {
     manualGrouping?: boolean;
     onGroupingChange?: OnChangeFn<GroupingState>;
     enableGrouping?: boolean;
     getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>;
     groupedColumnMode?: false | 'reorder' | 'remove';
-}
-declare type ResolvedAggregationFns = keyof AggregationFns extends never ? {
+} & (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';
-interface GroupingInstance<TData extends RowData> {
+declare type 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>;
-interface ExpandedTableState {
+declare type ExpandedTableState = {
     expanded: ExpandedState;
-}
-interface ExpandedRow {
+};
+declare type ExpandedRow = {
     toggleExpanded: (expanded?: boolean) => void;
     getIsExpanded: () => boolean;
     getCanExpand: () => boolean;
     getToggleExpandedHandler: () => () => void;
-}
-interface ExpandedOptions<TData extends RowData> {
+};
+declare type ExpandedOptions<TData extends RowData> = {
     manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
@@ -420,8 +411,8 @@ interface ExpandedOptions<TData extends RowData> {
     getIsRowExpanded?: (row: Row<TData>) => boolean;
     getRowCanExpand?: (row: Row<TData>) => boolean;
     paginateExpandedRows?: boolean;
-}
-interface ExpandedInstance<TData extends RowData> {
+};
+declare type ExpandedInstance<TData extends RowData> = {
     _autoResetExpanded: () => void;
     setExpanded: (updater: Updater<ExpandedState>) => void;
     toggleAllRowsExpanded: (expanded?: boolean) => void;
@@ -434,35 +425,35 @@ interface ExpandedInstance<TData extends RowData> {
     getExpandedRowModel: () => RowModel<TData>;
     _getExpandedRowModel?: () => RowModel<TData>;
     getPreExpandedRowModel: () => RowModel<TData>;
-}
+};
 declare const Expanding: TableFeature;
 
-interface ColumnSizingTableState {
+declare type ColumnSizingTableState = {
     columnSizing: ColumnSizingState;
     columnSizingInfo: ColumnSizingInfoState;
-}
+};
 declare type ColumnSizingState = Record<string, number>;
-interface ColumnSizingInfoState {
+declare type ColumnSizingInfoState = {
     startOffset: null | number;
     startSize: null | number;
     deltaOffset: null | number;
     deltaPercentage: null | number;
     isResizingColumn: false | string;
     columnSizingStart: [string, number][];
-}
+};
 declare type ColumnResizeMode = 'onChange' | 'onEnd';
-interface ColumnSizingOptions {
+declare type ColumnSizingOptions = {
     enableColumnResizing?: boolean;
     columnResizeMode?: ColumnResizeMode;
     onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
-}
-interface ColumnSizingDefaultOptions {
+};
+declare type ColumnSizingDefaultOptions = {
     columnResizeMode: ColumnResizeMode;
     onColumnSizingChange: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
-}
-interface ColumnSizingInstance {
+};
+declare type ColumnSizingInstance = {
     setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
     setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
     resetColumnSizing: (defaultState?: boolean) => void;
@@ -471,25 +462,25 @@ interface ColumnSizingInstance {
     getLeftTotalSize: () => number;
     getCenterTotalSize: () => number;
     getRightTotalSize: () => number;
-}
-interface ColumnSizingColumnDef {
+};
+declare type ColumnSizingColumnDef = {
     enableResizing?: boolean;
     size?: number;
     minSize?: number;
     maxSize?: number;
-}
-interface ColumnSizingColumn {
+};
+declare type ColumnSizingColumn = {
     getSize: () => number;
     getStart: (position?: ColumnPinningPosition) => number;
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
     resetSize: () => void;
-}
-interface ColumnSizingHeader {
+};
+declare type ColumnSizingHeader = {
     getSize: () => number;
     getStart: (position?: ColumnPinningPosition) => number;
     getResizeHandler: () => (event: unknown) => void;
-}
+};
 declare const defaultColumnSizing: {
     size: number;
     minSize: number;
@@ -498,27 +489,27 @@ declare const defaultColumnSizing: {
 declare const ColumnSizing: TableFeature;
 declare function passiveEventSupported(): boolean;
 
-interface PaginationState {
+declare type PaginationState = {
     pageIndex: number;
     pageSize: number;
-}
-interface PaginationTableState {
+};
+declare type PaginationTableState = {
     pagination: PaginationState;
-}
-interface PaginationInitialTableState {
+};
+declare type PaginationInitialTableState = {
     pagination?: Partial<PaginationState>;
-}
-interface PaginationOptions {
+};
+declare type PaginationOptions = {
     pageCount?: number;
     manualPagination?: boolean;
     onPaginationChange?: OnChangeFn<PaginationState>;
     autoResetPageIndex?: boolean;
     getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>;
-}
-interface PaginationDefaultOptions {
+};
+declare type PaginationDefaultOptions = {
     onPaginationChange: OnChangeFn<PaginationState>;
-}
-interface PaginationInstance<TData extends RowData> {
+};
+declare type PaginationInstance<TData extends RowData> = {
     _autoResetPageIndex: () => void;
     setPagination: (updater: Updater<PaginationState>) => void;
     resetPagination: (defaultState?: boolean) => void;
@@ -536,20 +527,20 @@ interface PaginationInstance<TData extends RowData> {
     getPaginationRowModel: () => RowModel<TData>;
     _getPaginationRowModel?: () => RowModel<TData>;
     getPageCount: () => number;
-}
+};
 declare const Pagination: TableFeature;
 
 declare type RowSelectionState = Record<string, boolean>;
-interface RowSelectionTableState {
+declare type RowSelectionTableState = {
     rowSelection: RowSelectionState;
-}
-interface RowSelectionOptions<TData extends RowData> {
+};
+declare type 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>;
-}
-interface RowSelectionRow {
+};
+declare type RowSelectionRow = {
     getIsSelected: () => boolean;
     getIsSomeSelected: () => boolean;
     getIsAllSubRowsSelected: () => boolean;
@@ -558,8 +549,8 @@ interface RowSelectionRow {
     getCanSelectSubRows: () => boolean;
     toggleSelected: (value?: boolean) => void;
     getToggleSelectedHandler: () => (event: unknown) => void;
-}
-interface RowSelectionInstance<TData extends RowData> {
+};
+declare type RowSelectionInstance<TData extends RowData> = {
     getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
     getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
     setRowSelection: (updater: Updater<RowSelectionState>) => void;
@@ -574,13 +565,13 @@ interface 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';
 
-interface CoreRow<TData extends RowData> {
+declare type CoreRow<TData extends RowData> = {
     id: string;
     index: number;
     original: TData;
@@ -595,28 +586,28 @@ interface 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>;
 
-interface CellContext<TData extends RowData, TValue> {
+declare type 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>;
-}
-interface CoreCell<TData extends RowData, TValue> {
+};
+declare type 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>;
 
-interface CoreColumn<TData extends RowData, TValue> {
+declare type CoreColumn<TData extends RowData, TValue> = {
     id: string;
     depth: number;
     accessorFn?: AccessorFn<TData, TValue>;
@@ -625,7 +616,7 @@ interface 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> {
@@ -644,120 +635,78 @@ 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;
-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> {
+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> = {
     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>>;
-interface StringHeaderIdentifier {
+declare type StringHeaderIdentifier = {
     header: string;
     id?: string;
-}
-interface IdIdentifier<TData extends RowData, TValue> {
+};
+declare type IdIdentifier<TData extends RowData, TValue> = {
     id: string;
     header?: StringOrTemplateHeader<TData, TValue>;
-}
+};
 declare type ColumnIdentifiers<TData extends RowData, TValue> = IdIdentifier<TData, TValue> | StringHeaderIdentifier;
-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> {
+declare type ColumnDefBase<TData extends RowData, TValue = unknown> = {
     getUniqueValues?: AccessorFn<TData, unknown[]>;
     footer?: ColumnDefTemplate<HeaderContext<TData, TValue>>;
     cell?: ColumnDefTemplate<CellContext<TData, TValue>>;
     meta?: ColumnMeta<TData, TValue>;
-}
-interface IdentifiedColumnDef<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
+} & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TData> & SortingColumnDef<TData> & GroupingColumnDef<TData, TValue> & ColumnSizingColumnDef;
+declare type IdentifiedColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & {
     id?: string;
     header?: StringOrTemplateHeader<TData, TValue>;
-}
+};
 declare type DisplayColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>;
-interface GroupColumnDefBase<TData extends RowData, TValue = unknown> extends ColumnDefBase<TData, TValue> {
+declare type GroupColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue> & {
     columns?: ColumnDef<TData, any>[];
-}
-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> {
+};
+declare type AccessorFnColumnDef<TData extends RowData, TValue = unknown> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue> & {
     accessorFn: AccessorFn<TData, TValue>;
-}
-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> {
+};
+declare type AccessorKeyColumnDef<TData extends RowData, TValue = unknown> = {
     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;
 };
-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 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>;
 
-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 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 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 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 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 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;
@@ -772,7 +721,7 @@ declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...
     onChange?: (result: TResult) => void;
 }): () => TResult;
 
-interface TableFeature {
+declare type TableFeature = {
     getDefaultOptions?: (table: any) => any;
     getInitialState?: (initialState?: InitialTableState) => any;
     createTable?: (table: any) => any;
@@ -781,10 +730,9 @@ interface TableFeature {
     createHeader?: (column: any, table: any) => any;
     createCell?: (cell: any, column: any, row: any, table: any) => any;
     createRow?: (row: any, table: any) => any;
-}
-interface CoreTableState {
-}
-interface CoreOptions<TData extends RowData> {
+};
+declare type CoreTableState = {};
+declare type CoreOptions<TData extends RowData> = {
     data: TData[];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
@@ -803,8 +751,8 @@ interface CoreOptions<TData extends RowData> {
     columns: ColumnDef<TData, any>[];
     defaultColumn?: Partial<ColumnDef<TData, unknown>>;
     renderFallbackValue: any;
-}
-interface CoreInstance<TData extends RowData> {
+};
+declare type CoreInstance<TData extends RowData> = {
     initialState: TableState;
     reset: () => void;
     options: RequiredKeys<TableOptionsResolved<TData>, 'state'>;
@@ -825,16 +773,14 @@ interface 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 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 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 function createColumnHelper<TData extends RowData>(): ColumnHelper<TData>;
 
 declare function getCoreRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;