@tanstack/table-core 8.0.0-alpha.58 → 8.0.0-alpha.61

package/build/types/core.d.ts

@@ -1,5 +1,5 @@
 import { RequiredKeys } from './utils';
-import { Updater, Options, TableState, TableProps, TableBodyProps, PropGetter, TableInstance, Renderable, UseRenderer, TableFeature, TableGenerics } from './types';
+import { Updater, TableOptions, TableState, TableInstance, Renderable, TableFeature, TableGenerics, InitialTableState } from './types';
 export declare type CoreTableState = {
     coreProgress: number;
 };
@@ -7,30 +7,28 @@ export declare type CoreOptions<TGenerics extends TableGenerics> = {
     data: TGenerics['Row'][];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
-    render: TGenerics['Render'];
+    render: TGenerics['Renderer'];
     debugAll?: boolean;
     debugTable?: boolean;
     debugHeaders?: boolean;
     debugColumns?: boolean;
     debugRows?: boolean;
-    initialState?: Partial<TableState>;
+    initialState?: InitialTableState;
     autoResetAll?: boolean;
-    mergeOptions?: (defaultOptions: TableFeature, options: Partial<Options<TGenerics>>) => Options<TGenerics>;
+    mergeOptions?: <T>(defaultOptions: T, options: Partial<T>) => T;
     meta?: TGenerics['TableMeta'];
 };
 export declare type TableCore<TGenerics extends TableGenerics> = {
     initialState: TableState;
     reset: () => void;
-    options: RequiredKeys<Options<TGenerics>, 'state'>;
-    setOptions: (newOptions: Updater<Options<TGenerics>>) => void;
+    options: RequiredKeys<TableOptions<TGenerics>, 'state'>;
+    setOptions: (newOptions: Updater<TableOptions<TGenerics>>) => void;
     queue: (cb: () => void) => void;
     willUpdate: () => void;
     getState: () => TableState;
     setState: (updater: Updater<TableState>) => void;
-    getTableProps: PropGetter<TableProps>;
-    getTableBodyProps: PropGetter<TableBodyProps>;
-    render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | ReturnType<UseRenderer<TGenerics>>;
+    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: Options<TGenerics>): TableInstance<TGenerics>;
+export declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptions<TGenerics>): TableInstance<TGenerics>;

package/build/types/createTable.d.ts

@@ -1,18 +1,19 @@
 import { CustomFilterFns, FilterFn } from './features/Filters';
 import { AggregationFn, CustomAggregationFns } from './features/Grouping';
 import { CustomSortingFns, SortingFn } from './features/Sorting';
-import { ColumnDef, AccessorFn, AnyRender, TableGenerics, Options } from './types';
-import { IfDefined, Overwrite, PartialKeys } from './utils';
+import { ColumnDef, AccessorFn, AnyRender, TableGenerics, TableOptions } from './types';
+import { IfDefined, Overwrite } from './utils';
 export declare type TableFactory<TGenerics extends TableGenerics> = () => Table<TGenerics>;
 export declare type CreateTableOptions<TRender extends AnyRender, TFilterFns extends CustomFilterFns<any>, TSortingFns extends CustomSortingFns<any>, TAggregationFns extends CustomAggregationFns<any>, TGenerics extends TableGenerics> = Partial<{
     render?: TRender;
     filterFns?: TFilterFns;
     sortingFns?: TSortingFns;
     aggregationFns?: TAggregationFns;
-} & Omit<Options<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
+} & Omit<TableOptions<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
 export declare type Table<TGenerics extends TableGenerics> = {
     generics: TGenerics;
-    options: Partial<Options<TGenerics>>;
+    options: Partial<TableOptions<TGenerics>>;
+    setGenerics: <T extends TableGenerics>() => Table<T>;
     setRowType: <TRow>() => Table<Overwrite<TGenerics, {
         Row: TRow;
     }>>;
@@ -27,7 +28,6 @@ export declare type Table<TGenerics extends TableGenerics> = {
         SortingFns: IfDefined<TSortingFns, TGenerics['SortingFns']>;
         AggregationFns: IfDefined<TAggregationFns, TGenerics['AggregationFns']>;
     }>>;
-    createColumns: <TColumnDef extends ColumnDef<any>>(columns: TColumnDef[]) => TColumnDef[];
     createGroup: (column: Overwrite<Overwrite<ColumnDef<any>, {
         header: string;
         id?: string;
@@ -39,9 +39,7 @@ export declare type Table<TGenerics extends TableGenerics> = {
         accessorKey?: never;
         columns?: ColumnDef<any>[];
     }>) => ColumnDef<TGenerics>;
-    createDisplayColumn: (column: Overwrite<PartialKeys<ColumnDef<TGenerics>, 'accessorFn' | 'accessorKey'>, {
-        columns?: ColumnDef<any>[];
-    }>) => ColumnDef<TGenerics>;
+    createDisplayColumn: (column: Omit<ColumnDef<TGenerics>, 'columns'>) => ColumnDef<TGenerics>;
     createDataColumn: <TAccessor extends AccessorFn<TGenerics['Row']> | keyof TGenerics['Row']>(accessor: TAccessor, column: Overwrite<TAccessor extends (...args: any[]) => any ? ColumnDef<Overwrite<TGenerics, {
         Value: ReturnType<TAccessor>;
     }>> : TAccessor extends keyof TGenerics['Row'] ? Overwrite<ColumnDef<Overwrite<TGenerics, {
@@ -54,8 +52,9 @@ export declare type Table<TGenerics extends TableGenerics> = {
         columns?: ColumnDef<any>[];
     }>) => ColumnDef<TGenerics>;
 };
-export declare function createTableFactory<TRender extends AnyRender>(opts: {
-    render: TRender;
+export declare function createTableFactory<TRenderer extends AnyRender>(opts: {
+    render: TRenderer;
 }): () => Table<{
-    Render: TRender;
+    Renderer: TRenderer;
+    Rendered: ReturnType<TRenderer>;
 }>;

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

@@ -1,4 +1,4 @@
-import { Cell, TableGenerics, TableInstance, Row, Column, Getter, CellProps, PropGetterValue } from '../types';
+import { Cell, TableGenerics, TableInstance, Row, Column } from '../types';
 export declare type CellsRow<TGenerics extends TableGenerics> = {
     getAllCells: () => Cell<TGenerics>[];
     getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
@@ -6,7 +6,6 @@ export declare type CellsRow<TGenerics extends TableGenerics> = {
 export declare type CellsInstance<TGenerics extends TableGenerics> = {
     createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
     getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
-    getCellProps: <TGetter extends Getter<CellProps>>(rowId: string, columnId: string, userProps?: TGetter) => undefined | PropGetterValue<CellProps, TGetter>;
 };
 export declare const Cells: {
     createRow: <TGenerics extends TableGenerics>(row: Row<TGenerics>, instance: TableInstance<TGenerics>) => CellsRow<TGenerics>;

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

@@ -1,4 +1,4 @@
-import { Column, Getter, Header, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Updater } from '../types';
+import { OnChangeFn, TableGenerics, Updater, TableFeature } from '../types';
 import { ColumnPinningPosition } from './Pinning';
 export declare type ColumnSizingTableState = {
     columnSizing: ColumnSizingState;
@@ -25,13 +25,6 @@ export declare type ColumnSizingDefaultOptions = {
     onColumnSizingChange: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
 };
-export declare type ColumnResizerProps = {
-    title?: string;
-    onMouseDown?: (e: MouseEvent) => void;
-    onTouchStart?: (e: TouchEvent) => void;
-    draggable?: boolean;
-    role?: string;
-};
 export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
     getColumnSize: (columnId: string) => number;
     getColumnStart: (columnId: string, position?: ColumnPinningPosition) => number;
@@ -43,7 +36,7 @@ export declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
     resetHeaderSizeInfo: () => void;
     getColumnCanResize: (columnId: string) => boolean;
     getHeaderCanResize: (headerId: string) => boolean;
-    getHeaderResizerProps: <TGetter extends Getter<ColumnResizerProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
+    getResizeHandler: (headerId: string) => (event: unknown) => void;
     getColumnIsResizing: (columnId: string) => boolean;
     getHeaderIsResizing: (headerId: string) => boolean;
     getTotalSize: () => number;
@@ -68,7 +61,7 @@ export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
 export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
-    getResizerProps: <TGetter extends Getter<ColumnResizerProps>>(userProps?: TGetter) => undefined | PropGetterValue<ColumnResizerProps, TGetter>;
+    getResizeHandler: () => (event: unknown) => void;
     resetSize: () => void;
 };
 export declare const defaultColumnSizing: {
@@ -76,12 +69,5 @@ export declare const defaultColumnSizing: {
     minSize: number;
     maxSize: number;
 };
-export declare const ColumnSizing: {
-    getDefaultColumn: () => ColumnSizingColumnDef;
-    getInitialState: () => ColumnSizingTableState;
-    getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnSizingDefaultOptions;
-    createColumn: <TGenerics_1 extends TableGenerics>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => ColumnSizingColumn<TGenerics_1>;
-    createHeader: <TGenerics_2 extends TableGenerics>(header: Header<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnSizingHeader<TGenerics_2>;
-    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => ColumnSizingInstance<TGenerics_3>;
-};
+export declare const ColumnSizing: TableFeature;
 export declare function passiveEventSupported(): boolean;

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

@@ -1,5 +1,5 @@
 import { RowModel } from '..';
-import { Getter, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Row, Updater } from '../types';
+import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 export declare type ExpandedStateList = Record<string, boolean>;
 export declare type ExpandedState = true | Record<string, boolean>;
 export declare type ExpandedTableState = {
@@ -9,7 +9,7 @@ export declare type ExpandedRow = {
     toggleExpanded: (expanded?: boolean) => void;
     getIsExpanded: () => boolean;
     getCanExpand: () => boolean;
-    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getToggleExpandedHandler: () => () => void;
 };
 export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
     manualExpanding?: boolean;
@@ -23,12 +23,8 @@ export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
     getRowCanExpand?: (row: Row<TGenerics>) => boolean;
     paginateExpandedRows?: boolean;
 };
-export declare type ToggleExpandedProps = {
-    title?: string;
-    onClick?: (event: unknown) => void;
-};
 export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
-    queueResetExpanded: () => void;
+    _autoResetExpanded: () => void;
     setExpanded: (updater: Updater<ExpandedState>) => void;
     toggleRowExpanded: (rowId: string, expanded?: boolean) => void;
     toggleAllRowsExpanded: (expanded?: boolean) => void;
@@ -36,8 +32,8 @@ export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
     getRowCanExpand: (rowId: string) => boolean;
     getCanSomeRowsExpand: () => boolean;
     getIsRowExpanded: (rowId: string) => boolean;
-    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
-    getToggleAllRowsExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getToggleExpandedHandler: (rowId: string) => undefined | (() => void);
+    getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
     getIsSomeRowsExpanded: () => boolean;
     getIsAllRowsExpanded: () => boolean;
     getExpandedDepth: () => number;

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

@@ -51,19 +51,16 @@ export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     enableFilters?: boolean;
     manualColumnFiltering?: boolean;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
-    autoResetColumnFilters?: boolean;
     enableColumnFilters?: boolean;
     getColumnFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     manualGlobalFiltering?: boolean;
     globalFilterFn?: FilterFnOption<TGenerics>;
     onGlobalFilterChange?: OnChangeFn<any>;
-    autoResetGlobalFilter?: boolean;
     enableGlobalFilter?: boolean;
     getGlobalFilteredRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     getColumnCanGlobalFilterFn?: (column: Column<TGenerics>) => boolean;
 };
 export declare type FiltersInstance<TGenerics extends TableGenerics> = {
-    queueResetFilters: () => void;
     getColumnAutoFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
     getColumnFilterFn: (columnId: string) => FilterFn<TGenerics> | undefined;
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;

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

@@ -1,6 +1,6 @@
 import { RowModel } from '..';
 import { BuiltInAggregationFn } from '../aggregationFns';
-import { Cell, Column, Getter, OnChangeFn, PropGetterValue, TableInstance, Row, Updater, Renderable, UseRenderer, TableGenerics } from '../types';
+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 TableGenerics> = (getLeafValues: () => TGenerics['Row'][], getChildValues: () => TGenerics['Row'][]) => any;
@@ -32,7 +32,7 @@ export declare type GroupingColumn<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
     getGroupedIndex: () => number;
     toggleGrouping: () => void;
-    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
+    getToggleGroupingHandler: () => () => void;
 };
 export declare type GroupingRow = {
     groupingColumnId?: string;
@@ -43,30 +43,23 @@ export declare type GroupingCell<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
     getIsPlaceholder: () => boolean;
     getIsAggregated: () => boolean;
-    renderAggregatedCell: () => string | null | ReturnType<UseRenderer<TGenerics>>;
+    renderAggregatedCell: () => string | null | TGenerics['Rendered'];
 };
 export declare type ColumnDefaultOptions = {
     onGroupingChange: OnChangeFn<GroupingState>;
-    autoResetGrouping: boolean;
     enableGrouping: boolean;
 };
 export declare type GroupingOptions<TGenerics extends TableGenerics> = {
     manualGrouping?: boolean;
     aggregationFns?: TGenerics['AggregationFns'];
     onGroupingChange?: OnChangeFn<GroupingState>;
-    autoResetGrouping?: boolean;
     enableGrouping?: boolean;
     enableGroupingRemoval?: boolean;
     getGroupedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     groupedColumnMode?: false | 'reorder' | 'remove';
 };
 export declare type GroupingColumnMode = false | 'reorder' | 'remove';
-export declare type ToggleGroupingProps = {
-    title?: string;
-    onClick?: (event: unknown) => void;
-};
 export declare type GroupingInstance<TGenerics extends TableGenerics> = {
-    queueResetGrouping: () => void;
     getColumnAutoAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
     getColumnAggregationFn: (columnId: string) => AggregationFn<TGenerics> | undefined;
     setGrouping: (updater: Updater<GroupingState>) => void;
@@ -75,7 +68,7 @@ export declare type GroupingInstance<TGenerics extends TableGenerics> = {
     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>;
+    getToggleGroupingHandler: (columnId: string) => undefined | (() => void);
     getRowIsGrouped: (rowId: string) => boolean;
     getPreGroupedRowModel: () => RowModel<TGenerics>;
     getGroupedRowModel: () => RowModel<TGenerics>;

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

@@ -1,4 +1,4 @@
-import { Column, FooterGroupProps, FooterProps, Getter, Header, HeaderGroup, HeaderGroupProps, HeaderProps, TableGenerics, PropGetterValue, TableInstance } from '../types';
+import { Column, Header, HeaderGroup, TableGenerics, TableInstance } from '../types';
 export declare type HeadersInstance<TGenerics extends TableGenerics> = {
     createHeader: (column: Column<TGenerics>, options: {
         id?: string;
@@ -24,10 +24,6 @@ export declare type HeadersInstance<TGenerics extends TableGenerics> = {
     getCenterLeafHeaders: () => Header<TGenerics>[];
     getRightLeafHeaders: () => Header<TGenerics>[];
     getHeader: (id: string) => Header<TGenerics>;
-    getHeaderGroupProps: <TGetter extends Getter<HeaderGroupProps>>(id: string, userProps?: TGetter) => undefined | PropGetterValue<HeaderGroupProps, TGetter>;
-    getFooterGroupProps: <TGetter extends Getter<FooterGroupProps>>(id: string, userProps?: TGetter) => undefined | PropGetterValue<FooterGroupProps, TGetter>;
-    getHeaderProps: <TGetter extends Getter<HeaderProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<HeaderProps, TGetter>;
-    getFooterProps: <TGetter extends Getter<FooterProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<FooterProps, TGetter>;
 };
 export declare const Headers: {
     createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => HeadersInstance<TGenerics>;

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

@@ -1,4 +1,4 @@
-import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater } from '../types';
+import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater, TableFeature } from '../types';
 export declare type PaginationState = {
     pageIndex: number;
     pageSize: number;
@@ -7,6 +7,9 @@ export declare type PaginationState = {
 export declare type PaginationTableState = {
     pagination: PaginationState;
 };
+export declare type PaginationInitialTableState = {
+    pagination?: Partial<PaginationState>;
+};
 export declare type PaginationOptions<TGenerics extends TableGenerics> = {
     manualPagination?: boolean;
     onPaginationChange?: OnChangeFn<PaginationState>;
@@ -18,7 +21,7 @@ export declare type PaginationDefaultOptions = {
     autoResetPageIndex: boolean;
 };
 export declare type PaginationInstance<TGenerics extends TableGenerics> = {
-    queueResetPageIndex: () => void;
+    _autoResetPageIndex: () => void;
     setPagination: (updater: Updater<PaginationState>) => void;
     resetPagination: () => void;
     setPageIndex: (updater: Updater<number>) => void;
@@ -36,8 +39,4 @@ export declare type PaginationInstance<TGenerics extends TableGenerics> = {
     _getPaginationRowModel?: () => RowModel<TGenerics>;
     getPageCount: () => number;
 };
-export declare const Pagination: {
-    getInitialState: () => PaginationTableState;
-    getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => PaginationDefaultOptions;
-    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => PaginationInstance<TGenerics_1>;
-};
+export declare const Pagination: TableFeature;

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

@@ -1,34 +1,26 @@
-import { Getter, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Row, RowModel, Updater } from '../types';
+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 TableGenerics> = {
     onRowSelectionChange?: OnChangeFn<RowSelectionState>;
-    autoResetRowSelection?: boolean;
     enableRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
     enableMultiRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
     enableSubRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
 };
-declare type ToggleRowSelectedProps = {
-    onChange?: (e: unknown) => void;
-    checked?: boolean;
-    title?: string;
-    indeterminate?: boolean;
-};
 export declare type RowSelectionRow = {
     getIsSelected: () => boolean;
     getIsSomeSelected: () => boolean;
     getCanSelect: () => boolean;
     getCanMultiSelect: () => 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 TableGenerics> = {
-    queueResetRowSelection: () => 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>;
+    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;
@@ -56,4 +48,3 @@ export declare const RowSelection: {
 };
 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';
-export {};

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

@@ -1,4 +1,4 @@
-import { TableGenerics, TableInstance, Row, Getter, PropGetterValue, RowProps, RowModel, RowValues, PropGetter } from '../types';
+import { TableGenerics, TableInstance, Row, RowModel, RowValues } from '../types';
 export declare type CoreRow<TGenerics extends TableGenerics> = {
     id: string;
     index: number;
@@ -7,12 +7,11 @@ export declare type CoreRow<TGenerics extends TableGenerics> = {
     values: RowValues;
     subRows: Row<TGenerics>[];
     getLeafRows: () => Row<TGenerics>[];
-    getRowProps: PropGetter<RowProps>;
     originalSubRows?: TGenerics['Row'][];
 };
 export declare type RowsOptions<TGenerics extends TableGenerics> = {
     getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
-    getSubRows?: (originalRow: TGenerics['Row'], index: number) => TGenerics['Row'][];
+    getSubRows?: (originalRow: TGenerics['Row'], index: number) => undefined | TGenerics['Row'][];
     getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
 };
 export declare type RowsInstance<TGenerics extends TableGenerics> = {
@@ -22,7 +21,6 @@ export declare type RowsInstance<TGenerics extends TableGenerics> = {
     _getCoreRowModel?: () => RowModel<TGenerics>;
     getRowModel: () => RowModel<TGenerics>;
     getRow: (id: string) => Row<TGenerics>;
-    getRowProps: <TGetter extends Getter<RowProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<RowProps, TGetter>;
 };
 export declare const Rows: {
     createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => RowsInstance<TGenerics>;

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

@@ -1,6 +1,6 @@
 import { RowModel } from '..';
 import { BuiltInSortingFn } from '../sortingFns';
-import { Column, Getter, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Row, Updater } from '../types';
+import { Column, OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 import { Overwrite } from '../utils';
 export declare type SortDirection = 'asc' | 'desc';
 export declare type ColumnSort = {
@@ -37,13 +37,12 @@ export declare type SortingColumn<TGenerics extends TableGenerics> = {
     getIsSorted: () => false | SortDirection;
     resetSorting: () => 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 TableGenerics> = {
     manualSorting?: boolean;
     sortingFns?: TGenerics['SortingFns'];
     onSortingChange?: OnChangeFn<SortingState>;
-    autoResetSorting?: boolean;
     enableSorting?: boolean;
     enableSortingRemoval?: boolean;
     enableMultiRemove?: boolean;
@@ -53,12 +52,7 @@ export declare type SortingOptions<TGenerics extends TableGenerics> = {
     maxMultiSortColCount?: number;
     isMultiSortEvent?: (e: unknown) => boolean;
 };
-export declare type ToggleSortingProps = {
-    title?: string;
-    onClick?: (event: unknown) => void;
-};
 export declare type SortingInstance<TGenerics extends TableGenerics> = {
-    queueResetSorting: () => void;
     getColumnAutoSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
     getColumnAutoSortDir: (columnId: string) => SortDirection;
     getColumnSortingFn: (columnId: string) => SortingFn<TGenerics> | undefined;
@@ -69,7 +63,7 @@ export declare type SortingInstance<TGenerics extends TableGenerics> = {
     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>;
+    getToggleSortingHandler: (columnId: string) => undefined | ((event: unknown) => void);
     getPreSortedRowModel: () => RowModel<TGenerics>;
     getSortedRowModel: () => RowModel<TGenerics>;
     _getSortedRowModel?: () => RowModel<TGenerics>;

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

@@ -1,4 +1,4 @@
-import { Cell, Column, Getter, OnChangeFn, TableGenerics, PropGetterValue, TableInstance, Updater, Row } from '../types';
+import { Cell, Column, OnChangeFn, TableGenerics, TableInstance, Updater, Row } from '../types';
 export declare type VisibilityOptions = {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;
@@ -23,10 +23,8 @@ export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     getColumnCanHide: (columnId: string) => boolean;
     getIsAllColumnsVisible: () => boolean;
     getIsSomeColumnsVisible: () => boolean;
-    getToggleAllColumnsVisibilityProps: <TGetter extends Getter<ToggleAllColumnsVisibilityProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleAllColumnsVisibilityProps, TGetter>;
+    getToggleAllColumnsVisibilityHandler: () => undefined | ((event: unknown) => void);
 };
-declare type ToggleVisibilityProps = {};
-declare type ToggleAllColumnsVisibilityProps = {};
 export declare type VisibilityColumnDef = {
     enableHiding?: boolean;
     defaultCanHide?: boolean;
@@ -40,7 +38,7 @@ export declare type VisibilityColumn = {
     getCanHide: () => boolean;
     getIsVisible: () => boolean;
     toggleVisibility: (value?: boolean) => void;
-    getToggleVisibilityProps: <TGetter extends Getter<ToggleVisibilityProps>>(userProps?: TGetter) => PropGetterValue<ToggleVisibilityProps, TGetter>;
+    getToggleVisibilityHandler: () => (event: unknown) => void;
 };
 export declare const Visibility: {
     getInitialState: () => VisibilityTableState;
@@ -52,4 +50,3 @@ export declare const Visibility: {
     createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => VisibilityRow<TGenerics_2>;
     createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => VisibilityInstance<TGenerics_3>;
 };
-export {};

package/build/types/filterFns.d.ts

@@ -6,6 +6,7 @@ export declare const filterFns: {
     equalsStringSensitive: typeof equalsStringSensitive;
     arrIncludes: typeof arrIncludes;
     arrIncludesAll: typeof arrIncludesAll;
+    arrIncludesSome: typeof arrIncludesSome;
     equals: typeof equals;
     weakEquals: typeof weakEquals;
     betweenNumberRange: typeof betweenNumberRange;
@@ -35,6 +36,10 @@ declare function arrIncludesAll<TGenerics extends TableGenerics>(rows: Row<TGene
 declare namespace arrIncludesAll {
     var autoRemove: (val: any) => boolean;
 }
+declare function arrIncludesSome<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown[]): Row<TGenerics>[];
+declare namespace arrIncludesSome {
+    var autoRemove: (val: any) => boolean;
+}
 declare function equals<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], columnIds: string[], filterValue: unknown): Row<TGenerics>[];
 declare namespace equals {
     var autoRemove: (val: any) => boolean;