@tanstack/table-core 8.0.0-alpha.9 → 8.0.0-beta.2

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

@@ -1,85 +1,71 @@
-import React, { MouseEvent, TouchEvent } from 'react';
 import { RowModel } from '..';
-import { BuiltInAggregationType } from '../aggregationTypes';
-import { Cell, Column, Getter, OnChangeFn, PropGetterValue, TableInstance, Row, Updater, PartialGenerics } from '../types';
+import { BuiltInAggregationFn } from '../aggregationFns';
+import { TableFeature } from '../core/instance';
+import { Cell, Column, OnChangeFn, TableInstance, Row, Updater, Renderable, TableGenerics } from '../types';
 import { Overwrite } from '../utils';
 export declare type GroupingState = string[];
-export declare type AggregationFn<TGenerics extends PartialGenerics> = (leafValues: TGenerics['Row'][], childValues: TGenerics['Row'][]) => any;
-export declare type CustomAggregationTypes<TGenerics extends PartialGenerics> = Record<string, AggregationFn<TGenerics>>;
-export declare type AggregationType<TGenerics extends PartialGenerics> = 'auto' | BuiltInAggregationType | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
 export declare type GroupingTableState = {
     grouping: GroupingState;
 };
-export declare type GroupingColumnDef<TGenerics extends PartialGenerics> = {
-    aggregationType?: AggregationType<Overwrite<TGenerics, {
+export declare type AggregationFn<TGenerics extends TableGenerics> = (columnId: string, leafRows: Row<TGenerics>[], childRows: Row<TGenerics>[]) => any;
+export declare type CustomAggregationFns<TGenerics extends TableGenerics> = Record<string, AggregationFn<TGenerics>>;
+export declare type AggregationFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInAggregationFn | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
+export declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
+    aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
-    aggregateValue?: (columnValue: unknown) => any;
-    renderAggregatedCell?: () => React.ReactNode;
+    aggregatedCell?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        row: Row<TGenerics>;
+        column: Column<TGenerics>;
+        cell: Cell<TGenerics>;
+        getValue: () => TGenerics['Value'];
+    }>;
     enableGrouping?: boolean;
-    defaultCanGroup?: boolean;
 };
-export declare type GroupingColumn<TGenerics extends PartialGenerics> = {
-    aggregationType?: AggregationType<Overwrite<TGenerics, {
+export declare type GroupingColumn<TGenerics extends TableGenerics> = {
+    aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
     getCanGroup: () => boolean;
     getIsGrouped: () => boolean;
     getGroupedIndex: () => number;
     toggleGrouping: () => void;
-    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
+    getToggleGroupingHandler: () => () => void;
+    getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getAggregationFn: () => AggregationFn<TGenerics> | undefined;
 };
 export declare type GroupingRow = {
     groupingColumnId?: string;
     groupingValue?: any;
     getIsGrouped: () => boolean;
+    _groupingValuesCache: Record<string, any>;
 };
-export declare type GroupingCell = {
+export declare type GroupingCell<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
     getIsPlaceholder: () => boolean;
     getIsAggregated: () => boolean;
+    renderAggregatedCell: () => string | null | TGenerics['Rendered'];
 };
 export declare type ColumnDefaultOptions = {
     onGroupingChange: OnChangeFn<GroupingState>;
-    autoResetGrouping: boolean;
     enableGrouping: boolean;
 };
-export declare type GroupingOptions<TGenerics extends PartialGenerics> = {
-    aggregationTypes?: TGenerics['AggregationFns'];
+export declare type GroupingOptions<TGenerics extends TableGenerics> = {
+    manualGrouping?: boolean;
+    aggregationFns?: TGenerics['AggregationFns'];
     onGroupingChange?: OnChangeFn<GroupingState>;
-    autoResetGrouping?: boolean;
     enableGrouping?: boolean;
-    enableGroupingRemoval?: boolean;
-    groupRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getGroupedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
     groupedColumnMode?: false | 'reorder' | 'remove';
 };
 export declare type GroupingColumnMode = false | 'reorder' | 'remove';
-export declare type ToggleGroupingProps = {
-    title?: string;
-    onClick?: (event: MouseEvent | TouchEvent) => void;
-};
-export declare type GroupingInstance<TGenerics extends PartialGenerics> = {
-    _notifyGroupingReset: () => void;
-    getColumnAutoAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
-    getColumnAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
+export declare type GroupingInstance<TGenerics extends TableGenerics> = {
     setGrouping: (updater: Updater<GroupingState>) => void;
-    resetGrouping: () => void;
-    toggleColumnGrouping: (columnId: string) => void;
-    getColumnCanGroup: (columnId: string) => boolean;
-    getColumnIsGrouped: (columnId: string) => boolean;
-    getColumnGroupedIndex: (columnId: string) => number;
-    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
-    getRowIsGrouped: (rowId: string) => boolean;
+    resetGrouping: (defaultState?: boolean) => void;
     getPreGroupedRowModel: () => RowModel<TGenerics>;
     getGroupedRowModel: () => RowModel<TGenerics>;
+    _getGroupedRowModel?: () => RowModel<TGenerics>;
 };
-export declare const Grouping: {
-    getDefaultColumn: <TGenerics extends Partial<import("..").DefaultGenerics>>() => GroupingColumnDef<TGenerics>;
-    getInitialState: () => GroupingTableState;
-    getDefaultOptions: <TGenerics_1 extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => GroupingOptions<TGenerics_1>;
-    createColumn: <TGenerics_2 extends Partial<import("..").DefaultGenerics>>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => GroupingColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics_3>) => GroupingInstance<TGenerics_3>;
-    createRow: <TGenerics_4 extends Partial<import("..").DefaultGenerics>>(row: Row<TGenerics_4>, instance: TableInstance<TGenerics_4>) => GroupingRow;
-    createCell: <TGenerics_5 extends Partial<import("..").DefaultGenerics>>(cell: Cell<TGenerics_5> & GroupingCell, column: Column<TGenerics_5>, row: Row<TGenerics_5>, _instance: TableInstance<TGenerics_5>) => GroupingCell;
-    orderColumns: <TGenerics_6 extends Partial<import("..").DefaultGenerics>>(leafColumns: Column<TGenerics_6>[], grouping: string[], groupedColumnMode?: GroupingColumnMode | undefined) => Column<TGenerics_6>[];
-};
+export declare const Grouping: TableFeature;
+export declare function orderColumns<TGenerics extends TableGenerics>(leafColumns: Column<TGenerics>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TGenerics>[];

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

@@ -1,21 +1,18 @@
-import { TableInstance, OnChangeFn, Updater, Column, PartialGenerics } from '../types';
-export declare type ColumnOrderState = string[];
+import { OnChangeFn, Updater, Column, TableGenerics } from '../types';
+import { TableFeature } from '../core/instance';
 export declare type ColumnOrderTableState = {
     columnOrder: ColumnOrderState;
 };
+export declare type ColumnOrderState = string[];
 export declare type ColumnOrderOptions = {
     onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
 };
 export declare type ColumnOrderDefaultOptions = {
     onColumnOrderChange: OnChangeFn<ColumnOrderState>;
 };
-export declare type ColumnOrderInstance<TGenerics extends PartialGenerics> = {
+export declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
     setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
-    resetColumnOrder: () => void;
-    getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
-};
-export declare const Ordering: {
-    getInitialState: () => ColumnOrderTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics>) => ColumnOrderDefaultOptions;
-    getInstance: <TGenerics_1 extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => ColumnOrderInstance<TGenerics_1>;
+    resetColumnOrder: (defaultState?: boolean) => void;
+    _getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
 };
+export declare const Ordering: TableFeature;

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

@@ -1,29 +1,33 @@
-import { OnChangeFn, PartialGenerics, TableInstance, RowModel, Updater } from '../types';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater } from '../types';
 export declare type PaginationState = {
     pageIndex: number;
     pageSize: number;
-    pageCount: number;
+    pageCount?: number;
 };
 export declare type PaginationTableState = {
     pagination: PaginationState;
 };
-export declare type PaginationOptions<TGenerics extends PartialGenerics> = {
+export declare type PaginationInitialTableState = {
+    pagination?: Partial<PaginationState>;
+};
+export declare type PaginationOptions<TGenerics extends TableGenerics> = {
+    manualPagination?: boolean;
     onPaginationChange?: OnChangeFn<PaginationState>;
     autoResetPageIndex?: boolean;
-    paginateRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getPaginationRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
 };
 export declare type PaginationDefaultOptions = {
     onPaginationChange: OnChangeFn<PaginationState>;
-    autoResetPageIndex: boolean;
 };
-export declare type PaginationInstance<TGenerics extends PartialGenerics> = {
-    _notifyPageIndexReset: () => void;
+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;
@@ -32,10 +36,7 @@ export declare type PaginationInstance<TGenerics extends PartialGenerics> = {
     nextPage: () => void;
     getPrePaginationRowModel: () => RowModel<TGenerics>;
     getPaginationRowModel: () => RowModel<TGenerics>;
+    _getPaginationRowModel?: () => RowModel<TGenerics>;
     getPageCount: () => number;
 };
-export declare const Pagination: {
-    getInitialState: () => PaginationTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics>) => PaginationDefaultOptions;
-    getInstance: <TGenerics_1 extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => PaginationInstance<TGenerics_1>;
-};
+export declare const Pagination: TableFeature;

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

@@ -1,5 +1,6 @@
-import { OnChangeFn, Updater, TableInstance, Column, PartialGenerics } from '../types';
-declare type ColumnPinningPosition = false | 'left' | 'right';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, Updater, Column, TableGenerics, Cell } from '../types';
+export declare type ColumnPinningPosition = false | 'left' | 'right';
 export declare type ColumnPinningState = {
     left?: string[];
     right?: string[];
@@ -16,7 +17,6 @@ export declare type ColumnPinningDefaultOptions = {
 };
 export declare type ColumnPinningColumnDef = {
     enablePinning?: boolean;
-    defaultCanPin?: boolean;
 };
 export declare type ColumnPinningColumn = {
     getCanPin: () => boolean;
@@ -24,18 +24,17 @@ export declare type ColumnPinningColumn = {
     getIsPinned: () => ColumnPinningPosition;
     pin: (position: ColumnPinningPosition) => void;
 };
-export declare type ColumnPinningInstance<TGenerics extends PartialGenerics> = {
+export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
+    getLeftVisibleCells: () => Cell<TGenerics>[];
+    getCenterVisibleCells: () => Cell<TGenerics>[];
+    getRightVisibleCells: () => Cell<TGenerics>[];
+};
+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;
-};
-export declare const Pinning: {
-    getInitialState: () => ColumnPinningTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics>) => ColumnPinningDefaultOptions;
-    createColumn: <TGenerics_1 extends Partial<import("../types").DefaultGenerics>>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => ColumnPinningColumn;
-    getInstance: <TGenerics_2 extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics_2>) => ColumnPinningInstance<TGenerics_2>;
-};
-export {};
+    resetColumnPinning: (defaultState?: boolean) => void;
+    getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
+    getLeftLeafColumns: () => Column<TGenerics>[];
+    getRightLeafColumns: () => Column<TGenerics>[];
+    getCenterLeafColumns: () => Column<TGenerics>[];
+};
+export declare const Pinning: TableFeature;

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

@@ -1,43 +1,29 @@
-import { MouseEvent, TouchEvent } from 'react';
-import { Getter, OnChangeFn, PartialGenerics, PropGetterValue, TableInstance, Row, RowModel, Updater } from '../types';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, Row, RowModel, Updater } from '../types';
 export declare type RowSelectionState = Record<string, boolean>;
 export declare type RowSelectionTableState = {
     rowSelection: RowSelectionState;
 };
-export declare type RowSelectionOptions<TGenerics extends PartialGenerics> = {
-    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
-    autoResetRowSelection?: boolean;
+export declare type RowSelectionOptions<TGenerics extends TableGenerics> = {
     enableRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
     enableMultiRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
     enableSubRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
-};
-declare type ToggleRowSelectedProps = {
-    onChange?: (e: MouseEvent | TouchEvent) => void;
-    checked?: boolean;
-    title?: string;
-    indeterminate?: boolean;
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
 };
 export declare type RowSelectionRow = {
     getIsSelected: () => boolean;
     getIsSomeSelected: () => boolean;
     getCanSelect: () => boolean;
     getCanMultiSelect: () => boolean;
+    getCanSelectSubRows: () => boolean;
     toggleSelected: (value?: boolean) => void;
-    getToggleSelectedProps: <TGetter extends Getter<ToggleRowSelectedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleRowSelectedProps, TGetter>;
+    getToggleSelectedHandler: () => (event: unknown) => void;
 };
-export declare type RowSelectionInstance<TGenerics extends PartialGenerics> = {
-    _notifyRowSelectionReset: () => void;
-    getToggleRowSelectedProps: <TGetter extends Getter<ToggleRowSelectedProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleRowSelectedProps, TGetter>;
-    getToggleAllRowsSelectedProps: <TGetter extends Getter<ToggleRowSelectedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleRowSelectedProps, TGetter>;
-    getToggleAllPageRowsSelectedProps: <TGetter extends Getter<ToggleRowSelectedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleRowSelectedProps, TGetter>;
+export declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
+    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;
@@ -49,12 +35,6 @@ export declare type RowSelectionInstance<TGenerics extends PartialGenerics> = {
     getFilteredSelectedRowModel: () => RowModel<TGenerics>;
     getGroupedSelectedRowModel: () => RowModel<TGenerics>;
 };
-export declare const RowSelection: {
-    getInitialState: () => RowSelectionTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics>) => RowSelectionOptions<TGenerics>;
-    getInstance: <TGenerics_1 extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => RowSelectionInstance<TGenerics_1>;
-    createRow: <TGenerics_2 extends Partial<import("../types").DefaultGenerics>>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => RowSelectionRow;
-};
-export declare function selectRowsFn<TGenerics extends PartialGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
-export declare function isRowSelected<TGenerics extends PartialGenerics>(row: Row<TGenerics>, selection: Record<string, boolean>, instance: TableInstance<TGenerics>): boolean | 'some';
-export {};
+export declare const RowSelection: TableFeature;
+export declare function selectRowsFn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
+export declare function isRowSelected<TGenerics extends TableGenerics>(row: Row<TGenerics>, selection: Record<string, boolean>, instance: TableInstance<TGenerics>): boolean | 'some';

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

@@ -1,7 +1,7 @@
-import { MouseEvent, TouchEvent } from 'react';
 import { RowModel } from '..';
-import { BuiltInSortType } from '../sortTypes';
-import { Column, Getter, OnChangeFn, PartialGenerics, PropGetterValue, TableInstance, Row, Updater } from '../types';
+import { TableFeature } from '../core/instance';
+import { BuiltInSortingFn } from '../sortingFns';
+import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 import { Overwrite } from '../utils';
 export declare type SortDirection = 'asc' | 'desc';
 export declare type ColumnSort = {
@@ -9,73 +9,54 @@ export declare type ColumnSort = {
     desc: boolean;
 };
 export declare type SortingState = ColumnSort[];
-export declare type SortingFn<TGenerics extends PartialGenerics> = {
-    (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
-};
-export declare type CustomSortingTypes<TGenerics extends PartialGenerics> = Record<string, SortingFn<TGenerics>>;
 export declare type SortingTableState = {
     sorting: SortingState;
 };
-export declare type SortType<TGenerics extends PartialGenerics> = 'auto' | BuiltInSortType | keyof TGenerics['SortingFns'] | SortingFn<TGenerics>;
-export declare type SortingColumnDef<TGenerics extends PartialGenerics> = {
-    sortType?: SortType<Overwrite<TGenerics, {
+export declare type SortingFn<TGenerics extends TableGenerics> = {
+    (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
+};
+export declare type CustomSortingFns<TGenerics extends TableGenerics> = Record<string, SortingFn<TGenerics>>;
+export declare type SortingFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInSortingFn | keyof TGenerics['SortingFns'] | SortingFn<TGenerics>;
+export declare type SortingColumnDef<TGenerics extends TableGenerics> = {
+    sortingFn?: SortingFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
     sortDescFirst?: boolean;
     enableSorting?: boolean;
     enableMultiSort?: boolean;
-    defaultCanSort?: boolean;
     invertSorting?: boolean;
     sortUndefined?: false | -1 | 1;
 };
-export declare type SortingColumn<TGenerics extends PartialGenerics> = {
-    sortType: SortType<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
+export declare type SortingColumn<TGenerics extends TableGenerics> = {
+    getAutoSortingFn: () => SortingFn<TGenerics>;
+    getAutoSortDir: () => SortDirection;
+    getSortingFn: () => SortingFn<TGenerics>;
     getCanSort: () => boolean;
     getCanMultiSort: () => boolean;
     getSortIndex: () => number;
     getIsSorted: () => false | SortDirection;
+    clearSorting: () => void;
     toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
-    getToggleSortingProps: <TGetter extends Getter<ToggleSortingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleSortingProps, TGetter>;
+    getToggleSortingHandler: () => undefined | ((event: unknown) => void);
 };
-export declare type SortingOptions<TGenerics extends PartialGenerics> = {
-    sortTypes?: TGenerics['SortingFns'];
+export declare type SortingOptions<TGenerics extends TableGenerics> = {
+    manualSorting?: boolean;
+    sortingFns?: TGenerics['SortingFns'];
     onSortingChange?: OnChangeFn<SortingState>;
-    autoResetSorting?: boolean;
     enableSorting?: boolean;
     enableSortingRemoval?: boolean;
     enableMultiRemove?: boolean;
     enableMultiSort?: boolean;
     sortDescFirst?: boolean;
-    sortRowsFn?: (instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>) => RowModel<TGenerics>;
+    getSortedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
     maxMultiSortColCount?: number;
-    isMultiSortEvent?: (e: MouseEvent | TouchEvent) => boolean;
+    isMultiSortEvent?: (e: unknown) => boolean;
 };
-export declare type ToggleSortingProps = {
-    title?: string;
-    onClick?: (event: MouseEvent | TouchEvent) => void;
-};
-export declare type SortingInstance<TGenerics extends PartialGenerics> = {
-    _notifySortingReset: () => void;
-    getColumnAutoSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
-    getColumnAutoSortDir: (columnId: string) => SortDirection;
-    getColumnSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
+export declare type SortingInstance<TGenerics extends TableGenerics> = {
     setSorting: (updater: Updater<SortingState>) => void;
-    toggleColumnSorting: (columnId: string, desc?: boolean, multi?: boolean) => void;
-    resetSorting: () => void;
-    getColumnCanSort: (columnId: string) => boolean;
-    getColumnCanMultiSort: (columnId: string) => boolean;
-    getColumnIsSorted: (columnId: string) => false | 'asc' | 'desc';
-    getColumnSortIndex: (columnId: string) => number;
-    getToggleSortingProps: <TGetter extends Getter<ToggleSortingProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleSortingProps, TGetter>;
+    resetSorting: (defaultState?: boolean) => void;
     getPreSortedRowModel: () => RowModel<TGenerics>;
     getSortedRowModel: () => RowModel<TGenerics>;
+    _getSortedRowModel?: () => RowModel<TGenerics>;
 };
-export declare const Sorting: {
-    getDefaultColumn: <TGenerics extends Partial<import("..").DefaultGenerics>>() => SortingColumnDef<TGenerics>;
-    getInitialState: () => SortingTableState;
-    getDefaultOptions: <TGenerics_1 extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics_1>) => SortingOptions<TGenerics_1>;
-    createColumn: <TGenerics_2 extends Partial<import("..").DefaultGenerics>>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => SortingColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends Partial<import("..").DefaultGenerics>>(instance: TableInstance<TGenerics_3>) => SortingInstance<TGenerics_3>;
-};
+export declare const Sorting: TableFeature;

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

@@ -1,4 +1,9 @@
-import { Cell, Column, Getter, OnChangeFn, PartialGenerics, PropGetterValue, TableInstance, Updater } from '../types';
+import { TableFeature } from '../core/instance';
+import { Cell, Column, OnChangeFn, TableGenerics, Updater } from '../types';
+export declare type VisibilityState = Record<string, boolean>;
+export declare type VisibilityTableState = {
+    columnVisibility: VisibilityState;
+};
 export declare type VisibilityOptions = {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;
@@ -6,44 +11,30 @@ export declare type VisibilityOptions = {
 export declare type VisibilityDefaultOptions = {
     onColumnVisibilityChange: OnChangeFn<VisibilityState>;
 };
-export declare type VisibilityState = Record<string, boolean>;
-export declare type VisibilityTableState = {
-    columnVisibility: VisibilityState;
-};
-export declare type VisibilityInstance<TGenerics extends PartialGenerics> = {
+export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     getVisibleFlatColumns: () => Column<TGenerics>[];
     getVisibleLeafColumns: () => Column<TGenerics>[];
+    getLeftVisibleLeafColumns: () => Column<TGenerics>[];
+    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;
-    getToggleAllColumnsVisibilityProps: <TGetter extends Getter<ToggleAllColumnsVisibilityProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleAllColumnsVisibilityProps, TGetter>;
+    getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
 };
-declare type ToggleVisibilityProps = {};
-declare type ToggleAllColumnsVisibilityProps = {};
 export declare type VisibilityColumnDef = {
     enableHiding?: boolean;
-    defaultCanHide?: boolean;
 };
-export declare type VisibilityRow<TGenerics extends PartialGenerics> = {
+export declare type VisibilityRow<TGenerics extends TableGenerics> = {
+    _getAllVisibleCells: () => Cell<TGenerics>[];
     getVisibleCells: () => Cell<TGenerics>[];
 };
 export declare type VisibilityColumn = {
     getCanHide: () => boolean;
     getIsVisible: () => boolean;
     toggleVisibility: (value?: boolean) => void;
-    getToggleVisibilityProps: <TGetter extends Getter<ToggleVisibilityProps>>(userProps?: TGetter) => PropGetterValue<ToggleVisibilityProps, TGetter>;
-};
-export declare const Visibility: {
-    getInitialState: () => VisibilityTableState;
-    getDefaultOptions: <TGenerics extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics>) => VisibilityDefaultOptions;
-    getDefaultColumn: () => {
-        defaultIsVisible: boolean;
-    };
-    createColumn: <TGenerics_1 extends Partial<import("../types").DefaultGenerics>>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => VisibilityColumn;
-    getInstance: <TGenerics_2 extends Partial<import("../types").DefaultGenerics>>(instance: TableInstance<TGenerics_2>) => VisibilityInstance<TGenerics_2>;
+    getToggleVisibilityHandler: () => (event: unknown) => void;
 };
-export {};
+export declare const Visibility: TableFeature;

package/build/types/filterFns.d.ts

@@ -0,0 +1,13 @@
+import { FilterFn } from './features/Filters';
+export declare const filterFns: {
+    includesString: FilterFn<any>;
+    includesStringSensitive: FilterFn<any>;
+    equalsString: FilterFn<any>;
+    arrIncludes: FilterFn<any>;
+    arrIncludesAll: FilterFn<any>;
+    arrIncludesSome: FilterFn<any>;
+    equals: FilterFn<any>;
+    weakEquals: FilterFn<any>;
+    inNumberRange: FilterFn<any>;
+};
+export declare type BuiltInFilterFn = keyof typeof filterFns;

package/build/types/index.d.ts

@@ -1,23 +1,29 @@
-export * from './core';
+export * from './core/instance';
 export * from './types';
 export * from './createTable';
-export * from './features/ColumnSizing';
+export * from './core/column';
+export * from './core/headers';
+export * from './core/row';
 export * from './features/ColumnSizing';
 export * from './features/Expanding';
 export * from './features/Filters';
 export * from './features/Grouping';
-export * from './features/Headers';
 export * from './features/Ordering';
 export * from './features/Pagination';
 export * from './features/Pinning';
 export * from './features/RowSelection';
 export * from './features/Sorting';
 export * from './features/Visibility';
-export * from './features/Expanding';
+export * from './filterFns';
+export * from './sortingFns';
+export * from './aggregationFns';
 export * from './utils';
-export * from './utils/columnFilterRowsFn';
-export * from './utils/globalFilterRowsFn';
-export * from './utils/sortRowsFn';
-export * from './utils/groupRowsFn';
-export * from './utils/expandRowsFn';
-export * from './utils/paginateRowsFn';
+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/sortingFns.d.ts

@@ -0,0 +1,11 @@
+import { SortingFn } from './features/Sorting';
+export declare const reSplitAlphaNumeric: RegExp;
+export declare const sortingFns: {
+    alphanumeric: SortingFn<any>;
+    alphanumericCaseSensitive: SortingFn<any>;
+    text: SortingFn<any>;
+    textCaseSensitive: SortingFn<any>;
+    datetime: SortingFn<any>;
+    basic: SortingFn<any>;
+};
+export declare type BuiltInSortingFn = keyof typeof sortingFns;