@tanstack/table-core 8.0.0-alpha.65 → 8.0.0-alpha.69

package/build/types/core.d.ts

@@ -1,8 +1,6 @@
 import { RequiredKeys } from './utils';
 import { Updater, TableOptions, TableState, TableInstance, Renderable, TableFeature, TableGenerics, InitialTableState } from './types';
-export declare type CoreTableState = {
-    coreProgress: number;
-};
+export declare type CoreTableState = {};
 export declare type CoreOptions<TGenerics extends TableGenerics> = {
     data: TGenerics['Row'][];
     state: Partial<TableState>;
@@ -16,9 +14,10 @@ export declare type CoreOptions<TGenerics extends TableGenerics> = {
     initialState?: InitialTableState;
     autoResetAll?: boolean;
     mergeOptions?: <T>(defaultOptions: T, options: Partial<T>) => T;
+    keepPreviousData?: boolean;
     meta?: TGenerics['TableMeta'];
 };
-export declare type TableCore<TGenerics extends TableGenerics> = {
+export declare type CoreInstance<TGenerics extends TableGenerics> = {
     initialState: TableState;
     reset: () => void;
     options: RequiredKeys<TableOptions<TGenerics>, 'state'>;
@@ -27,7 +26,6 @@ export declare type TableCore<TGenerics extends TableGenerics> = {
     getState: () => TableState;
     setState: (updater: Updater<TableState>) => void;
     render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | TGenerics['Rendered'];
-    getOverallProgress: () => number;
     _features: readonly TableFeature[];
 };
 export declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptions<TGenerics>): TableInstance<TGenerics>;

package/build/types/features/Cells.d.ts

@@ -4,7 +4,7 @@ export declare type CellsRow<TGenerics extends TableGenerics> = {
     getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
 };
 export declare type CellsInstance<TGenerics extends TableGenerics> = {
-    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
+    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, columnId: string) => Cell<TGenerics>;
     getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
 };
 export declare const Cells: {

package/build/types/features/ColumnSizing.d.ts

@@ -26,19 +26,10 @@ export declare type ColumnSizingDefaultOptions = {
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
 };
 export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
-    getColumnSize: (columnId: string) => number;
-    getColumnStart: (columnId: string, position?: ColumnPinningPosition) => number;
     setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
     setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
-    resetColumnSizing: () => void;
-    resetColumnSize: (columnId: string) => void;
-    resetHeaderSize: (headerId: string) => void;
-    resetHeaderSizeInfo: () => void;
-    getColumnCanResize: (columnId: string) => boolean;
-    getHeaderCanResize: (headerId: string) => boolean;
-    getResizeHandler: (headerId: string) => (event: unknown) => void;
-    getColumnIsResizing: (columnId: string) => boolean;
-    getHeaderIsResizing: (headerId: string) => boolean;
+    resetColumnSizing: (defaultState?: boolean) => void;
+    resetHeaderSizeInfo: (defaultState?: boolean) => void;
     getTotalSize: () => number;
     getLeftTotalSize: () => number;
     getCenterTotalSize: () => number;
@@ -46,7 +37,6 @@ export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
 };
 export declare type ColumnSizingColumnDef = {
     enableResizing?: boolean;
-    defaultCanResize?: boolean;
     size?: number;
     minSize?: number;
     maxSize?: number;
@@ -59,10 +49,9 @@ export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
     resetSize: () => void;
 };
 export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
-    getCanResize: () => boolean;
-    getIsResizing: () => boolean;
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
     getResizeHandler: () => (event: unknown) => void;
-    resetSize: () => void;
 };
 export declare const defaultColumnSizing: {
     size: number;

package/build/types/features/Columns.d.ts

@@ -20,7 +20,7 @@ export declare type CoreColumnDef<TGenerics extends TableGenerics> = {
         row: Row<TGenerics>;
         column: Column<TGenerics>;
         cell: Cell<TGenerics>;
-        value: TGenerics['Value'];
+        getValue: () => TGenerics['Value'];
     }>;
     meta?: TGenerics['ColumnMeta'];
 };

package/build/types/features/Expanding.d.ts

@@ -15,10 +15,9 @@ export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
     manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
-    enableExpanded?: boolean;
+    enableExpanding?: boolean;
     getExpandedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     expandSubRows?: boolean;
-    defaultCanExpand?: boolean;
     getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
     getRowCanExpand?: (row: Row<TGenerics>) => boolean;
     paginateExpandedRows?: boolean;
@@ -26,13 +25,9 @@ export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
 export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
     _autoResetExpanded: () => void;
     setExpanded: (updater: Updater<ExpandedState>) => void;
-    toggleRowExpanded: (rowId: string, expanded?: boolean) => void;
     toggleAllRowsExpanded: (expanded?: boolean) => void;
-    resetExpanded: () => void;
-    getRowCanExpand: (rowId: string) => boolean;
+    resetExpanded: (defaultState?: boolean) => void;
     getCanSomeRowsExpand: () => boolean;
-    getIsRowExpanded: (rowId: string) => boolean;
-    getToggleExpandedHandler: (rowId: string) => undefined | (() => void);
     getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
     getIsSomeRowsExpanded: () => boolean;
     getIsAllRowsExpanded: () => boolean;

package/build/types/features/Filters.d.ts

@@ -5,14 +5,17 @@ import { Overwrite } from '../utils';
 export declare type FiltersTableState = {
     columnFilters: ColumnFiltersState;
     globalFilter: any;
-    columnFiltersProgress: number;
-    globalFilterProgress: number;
 };
 export declare type ColumnFiltersState = ColumnFilter[];
 export declare type ColumnFilter = {
     id: string;
     value: unknown;
 };
+export declare type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+    id: string;
+    resolvedValue: unknown;
+    filterFn: FilterFn<TGenerics>;
+};
 export declare type FilterFn<TGenerics extends TableGenerics> = {
     (row: Row<TGenerics>, columnId: string, filterValue: any): boolean;
     resolveFilterValue?: TransformFilterValueFn<TGenerics>;
@@ -34,15 +37,20 @@ export declare type FiltersColumn<TGenerics extends TableGenerics> = {
     filterFn: FilterFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
-    getCanColumnFilter: () => boolean;
+    getAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getFilterFn: () => FilterFn<TGenerics> | undefined;
+    setFilterValue: (updater: Updater<any>) => void;
+    getCanFilter: () => boolean;
     getCanGlobalFilter: () => boolean;
-    getColumnFilterIndex: () => number;
-    getColumnIsFiltered: () => boolean;
-    getColumnFilterValue: () => unknown;
-    setColumnFilterValue: (updater: Updater<any>) => void;
     getFacetedRowModel: () => RowModel<TGenerics>;
+    _getFacetedRowModel?: () => RowModel<TGenerics>;
+    getIsFiltered: () => boolean;
+    getFilterValue: () => unknown;
+    getFilterIndex: () => number;
     getFacetedUniqueValues: () => Map<any, number>;
+    _getFacetedUniqueValues?: () => Map<any, number>;
     getFacetedMinMaxValues: () => [any, any];
+    _getFacetedMinMaxValues?: () => [any, any];
 };
 export declare type FiltersRow<TGenerics extends TableGenerics> = {
     columnFilterMap: Record<string, boolean>;
@@ -53,38 +61,33 @@ export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     manualFiltering?: boolean;
     filterFromLeafRows?: boolean;
     filterFns?: TGenerics['FilterFns'];
+    getFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
     enableColumnFilters?: boolean;
-    getFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     globalFilterFn?: FilterFnOption<TGenerics>;
     onGlobalFilterChange?: OnChangeFn<any>;
     enableGlobalFilter?: boolean;
     getColumnCanGlobalFilter?: (column: Column<TGenerics>) => boolean;
+    getFacetedRowModel?: (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;
+    getFacetedUniqueValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;
+    getFacetedMinMaxValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => [number, number];
 };
 export declare type FiltersInstance<TGenerics extends TableGenerics> = {
-    getColumnAutoFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
-    getColumnFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
-    setColumnFilterValue: (columnId: string, updater: Updater<any>) => void;
-    resetColumnFilters: () => void;
-    getColumnCanColumnFilter: (columnId: string) => boolean;
-    getColumnFacetedRowModel: (columnId: string) => RowModel<TGenerics>;
-    getColumnIsFiltered: (columnId: string) => boolean;
-    getColumnFilterValue: (columnId: string) => unknown;
-    getColumnFilterIndex: (columnId: string) => number;
+    resetColumnFilters: (defaultState?: boolean) => void;
     getPreFilteredRowModel: () => RowModel<TGenerics>;
     getFilteredRowModel: () => RowModel<TGenerics>;
     _getFilteredRowModel?: () => RowModel<TGenerics>;
     setGlobalFilter: (updater: Updater<any>) => void;
-    resetGlobalFilter: () => void;
+    resetGlobalFilter: (defaultState?: boolean) => void;
     getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
     getGlobalFilterFn: () => FilterFn<TGenerics> | undefined;
-    getColumnCanGlobalFilter: (columnId: string) => boolean;
     getGlobalFacetedRowModel: () => RowModel<TGenerics>;
+    _getGlobalFacetedRowModel?: () => RowModel<TGenerics>;
     getGlobalFacetedUniqueValues: () => Map<any, number>;
+    _getGlobalFacetedUniqueValues?: () => Map<any, number>;
     getGlobalFacetedMinMaxValues: () => [number, number];
+    _getGlobalFacetedMinMaxValues?: () => [number, number];
 };
 export declare const Filters: TableFeature;
 export declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;
-export declare function getRowModelMinMaxValues<TGenerics extends TableGenerics>(rowModel: RowModel<TGenerics>, columnId: string): [any, any];
-export declare function getRowModelUniqueValues<TGenerics extends TableGenerics>(rowModel: RowModel<TGenerics>, columnId: string): Map<any, number>;

package/build/types/features/Grouping.d.ts

@@ -19,10 +19,9 @@ export declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
         row: Row<TGenerics>;
         column: Column<TGenerics>;
         cell: Cell<TGenerics>;
-        value: TGenerics['Value'];
+        getValue: () => TGenerics['Value'];
     }>;
     enableGrouping?: boolean;
-    defaultCanGroup?: boolean;
 };
 export declare type GroupingColumn<TGenerics extends TableGenerics> = {
     aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
@@ -33,11 +32,14 @@ export declare type GroupingColumn<TGenerics extends TableGenerics> = {
     getGroupedIndex: () => number;
     toggleGrouping: () => void;
     getToggleGroupingHandler: () => () => void;
+    getColumnAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getColumnAggregationFn: () => AggregationFn<TGenerics> | undefined;
 };
 export declare type GroupingRow = {
     groupingColumnId?: string;
     groupingValue?: any;
     getIsGrouped: () => boolean;
+    groupingValuesCache: Record<string, any>;
 };
 export declare type GroupingCell<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
@@ -60,16 +62,8 @@ export declare type GroupingOptions<TGenerics extends TableGenerics> = {
 };
 export declare type GroupingColumnMode = false | 'reorder' | 'remove';
 export declare type GroupingInstance<TGenerics extends TableGenerics> = {
-    getColumnAutoAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
-    getColumnAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
     setGrouping: (updater: Updater<GroupingState>) => void;
-    resetGrouping: () => void;
-    toggleColumnGrouping: (columnId: string) => void;
-    getColumnCanGroup: (columnId: string) => boolean;
-    getColumnIsGrouped: (columnId: string) => boolean;
-    getColumnGroupedIndex: (columnId: string) => number;
-    getToggleGroupingHandler: (columnId: string) => undefined | (() => void);
-    getRowIsGrouped: (rowId: string) => boolean;
+    resetGrouping: (defaultState?: boolean) => void;
     getPreGroupedRowModel: () => RowModel<TGenerics>;
     getGroupedRowModel: () => RowModel<TGenerics>;
     _getGroupedRowModel?: () => RowModel<TGenerics>;

package/build/types/features/Ordering.d.ts

@@ -11,7 +11,7 @@ export declare type ColumnOrderDefaultOptions = {
 };
 export declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
     setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
-    resetColumnOrder: () => void;
+    resetColumnOrder: (defaultState?: boolean) => void;
     _getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
 };
 export declare const Ordering: TableFeature;

package/build/types/features/Pagination.d.ts

@@ -23,11 +23,11 @@ export declare type PaginationDefaultOptions = {
 export declare type PaginationInstance<TGenerics extends TableGenerics> = {
     _autoResetPageIndex: () => void;
     setPagination: (updater: Updater<PaginationState>) => void;
-    resetPagination: () => void;
+    resetPagination: (defaultState?: boolean) => void;
     setPageIndex: (updater: Updater<number>) => void;
-    resetPageIndex: () => void;
+    resetPageIndex: (defaultState?: boolean) => void;
     setPageSize: (updater: Updater<number>) => void;
-    resetPageSize: () => void;
+    resetPageSize: (defaultState?: boolean) => void;
     setPageCount: (updater: Updater<number>) => void;
     getPageOptions: () => number[];
     getCanPreviousPage: () => boolean;

package/build/types/features/Pinning.d.ts

@@ -30,11 +30,7 @@ export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
 };
 export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
     setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
-    resetColumnPinning: () => void;
-    pinColumn: (columnId: string, position: ColumnPinningPosition) => void;
-    getColumnCanPin: (columnId: string) => boolean;
-    getColumnIsPinned: (columnId: string) => ColumnPinningPosition;
-    getColumnPinnedIndex: (columnId: string) => number;
+    resetColumnPinning: (defaultState?: boolean) => void;
     getIsSomeColumnsPinned: () => boolean;
     getLeftLeafColumns: () => Column<TGenerics>[];
     getRightLeafColumns: () => Column<TGenerics>[];

package/build/types/features/RowSelection.d.ts

@@ -14,21 +14,15 @@ export declare type RowSelectionRow = {
     getIsSomeSelected: () => boolean;
     getCanSelect: () => boolean;
     getCanMultiSelect: () => boolean;
+    getCanSelectSubRows: () => boolean;
     toggleSelected: (value?: boolean) => void;
     getToggleSelectedHandler: () => (event: unknown) => void;
 };
 export declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
-    getToggleRowSelectedHandler: (rowId: string) => undefined | ((e: unknown) => void);
     getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
     getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
     setRowSelection: (updater: Updater<RowSelectionState>) => void;
-    resetRowSelection: () => void;
-    toggleRowSelected: (rowId: string, value?: boolean) => void;
-    getRowCanSelect: (rowId: string) => boolean;
-    getRowCanSelectSubRows: (rowId: string) => boolean;
-    getRowCanMultiSelect: (rowId: string) => boolean;
-    getRowIsSelected: (rowId: string) => boolean;
-    getRowIsSomeSelected: (rowId: string) => boolean;
+    resetRowSelection: (defaultState?: boolean) => void;
     getIsAllRowsSelected: () => boolean;
     getIsAllPageRowsSelected: () => boolean;
     getIsSomeRowsSelected: () => boolean;

package/build/types/features/Rows.d.ts

@@ -1,10 +1,11 @@
-import { TableGenerics, TableInstance, Row, RowModel, RowValues } from '../types';
+import { TableGenerics, TableInstance, Row, RowModel } from '../types';
 export declare type CoreRow<TGenerics extends TableGenerics> = {
     id: string;
     index: number;
     original?: TGenerics['Row'];
     depth: number;
-    values: RowValues;
+    valuesCache: Record<string, any>;
+    getValue: (columnId: string) => any;
     subRows: Row<TGenerics>[];
     getLeafRows: () => Row<TGenerics>[];
     originalSubRows?: TGenerics['Row'][];
@@ -16,7 +17,7 @@ export declare type RowsOptions<TGenerics extends TableGenerics> = {
 };
 export declare type RowsInstance<TGenerics extends TableGenerics> = {
     getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
-    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TGenerics>;
+    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, subRows?: Row<TGenerics>[]) => Row<TGenerics>;
     getCoreRowModel: () => RowModel<TGenerics>;
     _getCoreRowModel?: () => RowModel<TGenerics>;
     getRowModel: () => RowModel<TGenerics>;

package/build/types/features/Sorting.d.ts

@@ -23,19 +23,18 @@ export declare type SortingColumnDef<TGenerics extends TableGenerics> = {
     sortDescFirst?: boolean;
     enableSorting?: boolean;
     enableMultiSort?: boolean;
-    defaultCanSort?: boolean;
     invertSorting?: boolean;
     sortUndefined?: false | -1 | 1;
 };
 export declare type SortingColumn<TGenerics extends TableGenerics> = {
-    sortingFn: SortingFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
+    getAutoSortingFn: () => SortingFn<TGenerics>;
+    getAutoSortDir: () => SortDirection;
+    getSortingFn: () => SortingFn<TGenerics>;
     getCanSort: () => boolean;
     getCanMultiSort: () => boolean;
     getSortIndex: () => number;
     getIsSorted: () => false | SortDirection;
-    resetSorting: () => void;
+    clearSorting: () => void;
     toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
     getToggleSortingHandler: () => undefined | ((event: unknown) => void);
 };
@@ -53,17 +52,8 @@ export declare type SortingOptions<TGenerics extends TableGenerics> = {
     isMultiSortEvent?: (e: unknown) => boolean;
 };
 export declare type SortingInstance<TGenerics extends TableGenerics> = {
-    getColumnAutoSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
-    getColumnAutoSortDir: (columnId: string) => SortDirection;
-    getColumnSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
     setSorting: (updater: Updater<SortingState>) => void;
-    toggleColumnSorting: (columnId: string, desc?: boolean, multi?: boolean) => void;
-    resetSorting: (columnId?: string) => void;
-    getColumnCanSort: (columnId: string) => boolean;
-    getColumnCanMultiSort: (columnId: string) => boolean;
-    getColumnIsSorted: (columnId: string) => false | 'asc' | 'desc';
-    getColumnSortIndex: (columnId: string) => number;
-    getToggleSortingHandler: (columnId: string) => undefined | ((event: unknown) => void);
+    resetSorting: (defaultState?: boolean) => void;
     getPreSortedRowModel: () => RowModel<TGenerics>;
     getSortedRowModel: () => RowModel<TGenerics>;
     _getSortedRowModel?: () => RowModel<TGenerics>;

package/build/types/features/Visibility.d.ts

@@ -17,17 +17,14 @@ export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     getRightVisibleLeafColumns: () => Column<TGenerics>[];
     getCenterVisibleLeafColumns: () => Column<TGenerics>[];
     setColumnVisibility: (updater: Updater<VisibilityState>) => void;
-    toggleColumnVisibility: (columnId: string, value?: boolean) => void;
+    resetColumnVisibility: (defaultState?: boolean) => void;
     toggleAllColumnsVisible: (value?: boolean) => void;
-    getColumnIsVisible: (columId: string) => boolean;
-    getColumnCanHide: (columnId: string) => boolean;
     getIsAllColumnsVisible: () => boolean;
     getIsSomeColumnsVisible: () => boolean;
     getToggleAllColumnsVisibilityHandler: () => undefined | ((event: unknown) => void);
 };
 export declare type VisibilityColumnDef = {
     enableHiding?: boolean;
-    defaultCanHide?: boolean;
     defaultIsVisible?: boolean;
 };
 export declare type VisibilityRow<TGenerics extends TableGenerics> = {

package/build/types/index.d.ts

@@ -15,10 +15,12 @@ export * from './features/Sorting';
 export * from './features/Visibility';
 export * from './features/Expanding';
 export * from './utils';
-export * from './utils/getCoreRowModelSync';
-export * from './utils/getCoreRowModelAsync';
-export * from './utils/getFilteredRowModelSync';
-export * from './utils/getSortedRowModelSync';
+export * from './utils/getCoreRowModel';
+export * from './utils/getFilteredRowModel';
+export * from './utils/getFacetedRowModel';
+export * from './utils/getFacetedUniqueValues';
+export * from './utils/getFacetedMinMaxValues';
+export * from './utils/getSortedRowModel';
 export * from './utils/getGroupedRowModel';
 export * from './utils/getExpandedRowModel';
 export * from './utils/getPaginationRowModel';

package/build/types/types.d.ts

@@ -1,4 +1,4 @@
-import { CoreOptions, CoreTableState, TableCore } from './core';
+import { CoreOptions, CoreTableState, CoreInstance } from './core';
 import { ColumnsOptions, CoreColumn, CoreColumnDef } from './features/Columns';
 import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
 import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
@@ -38,7 +38,7 @@ export declare type TableFeature = {
     createCell?: (cell: any, column: any, row: any, instance: any) => any;
     createRow?: (row: any, instance: any) => any;
 };
-export declare type TableInstance<TGenerics extends TableGenerics> = TableCore<TGenerics> & ColumnsInstance<TGenerics> & RowsInstance<TGenerics> & CellsInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
+export declare type TableInstance<TGenerics extends TableGenerics> = CoreInstance<TGenerics> & ColumnsInstance<TGenerics> & RowsInstance<TGenerics> & CellsInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
 export declare type TableOptions<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & ColumnsOptions<TGenerics> & RowsOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
 export declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
 export declare type InitialTableState = Partial<CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationInitialTableState & RowSelectionTableState>;
@@ -60,7 +60,7 @@ export declare type CoreCell<TGenerics extends TableGenerics> = {
     id: string;
     rowId: string;
     columnId: string;
-    value: TGenerics['Value'];
+    getValue: () => TGenerics['Value'];
     row: Row<TGenerics>;
     column: Column<TGenerics>;
     renderCell: () => string | null | TGenerics['Rendered'];
@@ -71,8 +71,6 @@ export declare type CoreHeader<TGenerics extends TableGenerics> = {
     index: number;
     depth: number;
     column: Column<TGenerics>;
-    getStart: () => number;
-    getSize: () => number;
     headerGroup: HeaderGroup<TGenerics>;
     subHeaders: Header<TGenerics>[];
     colSpan?: number;
@@ -92,14 +90,4 @@ export declare type HeaderGroup<TGenerics extends TableGenerics> = {
     depth: number;
     headers: Header<TGenerics>[];
 };
-export declare type HeaderRenderProps<THeader> = {
-    header: THeader;
-};
-export declare type FooterRenderProps<THeader> = {
-    header: THeader;
-};
-export declare type CellRenderProps<TCell, TRow> = {
-    cell: TCell;
-    row: TRow;
-};
 export declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];

package/build/types/utils/filterRowsUtils.d.ts

@@ -1,4 +1,4 @@
 import { TableGenerics, Row, RowModel, TableInstance } from '../types';
-export declare function filterRows<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
-export declare function filterRowModelFromLeafs<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRows: (rowsToFilter: Row<TGenerics>[], depth: number) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
-export declare function filterRowModelFromRoot<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRows: (rowsToFilter: Row<TGenerics>[], depth: number) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRows<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], filterRowImpl: (row: Row<TGenerics>) => any, instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRowModelFromLeafs<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRow: (row: Row<TGenerics>) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRowModelFromRoot<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRow: (row: Row<TGenerics>) => any, instance: TableInstance<TGenerics>): RowModel<TGenerics>;

package/build/types/utils/getCoreRowModel.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, TableGenerics } from '../types';
+export declare function getCoreRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getFacetedMinMaxValues.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, TableGenerics } from '../types';
+export declare function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => [number, number];

package/build/types/utils/getFacetedRowModel.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, TableGenerics } from '../types';
+export declare function getFacetedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;

package/build/types/utils/getFacetedUniqueValues.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, TableGenerics } from '../types';
+export declare function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;

package/build/types/utils/{getCoreRowModelSync.d.ts → getFilteredRowModel.d.ts}

@@ -1,2 +1,2 @@
 import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getCoreRowModelSync<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+export declare function getFilteredRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getGroupedRowModel.d.ts

@@ -1,2 +1,2 @@
 import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getGroupedRowModelSync<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+export declare function getGroupedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getSortedRowModel.d.ts

@@ -0,0 +1,2 @@
+import { TableInstance, RowModel, TableGenerics } from '../types';
+export declare function getSortedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils.d.ts

@@ -7,11 +7,6 @@ export declare type Overwrite<T, U extends {
 export declare type IfDefined<T, N> = 0 extends 1 & T ? N : T extends {} ? T : N;
 export declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
 export declare function noop(): void;
-export declare function getBatchGroups<T>(arr: T[], count: number): {
-    start: number;
-    end: number;
-    items: T[];
-}[];
 export declare function makeStateUpdater(key: keyof TableState, instance: unknown): (updater: Updater<any>) => void;
 declare type AnyFunction = (...args: any) => any;
 export declare function isFunction<T extends AnyFunction>(d: any): d is T;
@@ -19,17 +14,6 @@ export declare function flattenBy<TNode>(arr: TNode[], getChildren: (item: TNode
 export declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
     key: any;
     debug?: () => any;
-    onChange?: (result: TResult, previousResult?: TResult) => void;
-}): () => TResult;
-declare type WorkFn = () => void;
-export declare function incrementalMemo<TDeps extends readonly any[], TResult>(getDeps: () => [...TDeps], getInitialValue: (...args: NoInfer<[...TDeps]>) => TResult, schedule: (...args: NoInfer<[...TDeps]>) => (resultRef: {
-    current: TResult;
-}) => (scheduler: (workFn: WorkFn) => void) => void, opts: {
-    key: any;
-    onProgress: (progress: number, nextResult: TResult, result?: TResult) => void;
-    onChange: (result: TResult, previousResult?: TResult) => void;
-    initialSync?: boolean;
-    timeout?: number;
-    debug?: () => any;
+    onChange?: (result: TResult) => void;
 }): () => TResult;
 export {};