@tanstack/table-core 8.0.0-alpha.55 → 8.0.0-alpha.59

package/build/types/core.d.ts

@@ -1,113 +1,34 @@
 import { RequiredKeys } from './utils';
-import { Updater, PropGetterValue, Options, TableState, ColumnDef, Row, Column, Cell, Header, AccessorFn, TableProps, TableBodyProps, PropGetter, Getter, RowProps, CellProps, TableInstance, RowValues, Renderable, UseRenderer, RowModel, TableFeature, TableGenerics } from './types';
+import { Updater, TableOptions, TableState, TableInstance, Renderable, TableFeature, TableGenerics, InitialTableState } from './types';
 export declare type CoreTableState = {
     coreProgress: number;
 };
 export declare type CoreOptions<TGenerics extends TableGenerics> = {
     data: TGenerics['Row'][];
-    columns: ColumnDef<TGenerics>[];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
-    render: TGenerics['Render'];
-    getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+    render: TGenerics['Renderer'];
     debugAll?: boolean;
     debugTable?: boolean;
     debugHeaders?: boolean;
     debugColumns?: boolean;
     debugRows?: boolean;
-    defaultColumn?: Partial<ColumnDef<TGenerics>>;
-    initialState?: Partial<TableState>;
-    getSubRows?: (originalRow: TGenerics['Row'], index: number) => TGenerics['Row'][];
-    getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    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;
-    getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
     getState: () => TableState;
     setState: (updater: Updater<TableState>) => void;
-    getDefaultColumn: () => Partial<ColumnDef<TGenerics>>;
-    getColumnDefs: () => ColumnDef<TGenerics>[];
-    createColumn: (columnDef: ColumnDef<TGenerics>, depth: number, parent?: Column<TGenerics>) => Column<TGenerics>;
-    getAllColumns: () => Column<TGenerics>[];
-    getAllFlatColumns: () => Column<TGenerics>[];
-    getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
-    getAllLeafColumns: () => Column<TGenerics>[];
-    getColumn: (columnId: string) => Column<TGenerics>;
-    getTotalWidth: () => number;
-    createCell: (row: Row<TGenerics>, column: Column<TGenerics>, value: any) => Cell<TGenerics>;
-    createRow: (id: string, original: TGenerics['Row'] | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TGenerics>;
-    getCoreRowModel: () => RowModel<TGenerics>;
-    _getCoreRowModel?: () => RowModel<TGenerics>;
-    getRowModel: () => RowModel<TGenerics>;
-    getRow: (id: string) => Row<TGenerics>;
-    getCell: (rowId: string, columnId: string) => Cell<TGenerics>;
-    getTableProps: PropGetter<TableProps>;
-    getTableBodyProps: PropGetter<TableBodyProps>;
-    getRowProps: <TGetter extends Getter<RowProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<RowProps, TGetter>;
-    getCellProps: <TGetter extends Getter<CellProps>>(rowId: string, columnId: string, userProps?: TGetter) => undefined | PropGetterValue<CellProps, TGetter>;
-    getTableWidth: () => number;
-    getLeftTableWidth: () => number;
-    getCenterTableWidth: () => number;
-    getRightTableWidth: () => number;
-    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 type CoreRow<TGenerics extends TableGenerics> = {
-    id: string;
-    index: number;
-    original?: TGenerics['Row'];
-    depth: number;
-    values: RowValues;
-    subRows: Row<TGenerics>[];
-    getLeafRows: () => Row<TGenerics>[];
-    getRowProps: PropGetter<RowProps>;
-    originalSubRows?: TGenerics['Row'][];
-    getAllCells: () => Cell<TGenerics>[];
-    getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
-};
-export declare type CoreColumnDef<TGenerics extends TableGenerics> = {
-    id: string;
-    accessorKey?: string & keyof TGenerics['Row'];
-    accessorFn?: AccessorFn<TGenerics['Row']>;
-    columns?: ColumnDef<TGenerics>[];
-    header?: Renderable<TGenerics, {
-        instance: TableInstance<TGenerics>;
-        header: Header<TGenerics>;
-        column: Column<TGenerics>;
-    }>;
-    footer?: Renderable<TGenerics, {
-        instance: TableInstance<TGenerics>;
-        header: Header<TGenerics>;
-        column: Column<TGenerics>;
-    }>;
-    cell?: Renderable<TGenerics, {
-        instance: TableInstance<TGenerics>;
-        row: Row<TGenerics>;
-        column: Column<TGenerics>;
-        cell: Cell<TGenerics>;
-        value: TGenerics['Value'];
-    }>;
-    meta?: TGenerics['ColumnMeta'];
-};
-export declare type CoreColumnDefType = 'data' | 'display' | 'group';
-export declare type CoreColumn<TGenerics extends TableGenerics> = {
-    id: string;
-    depth: number;
-    accessorFn?: AccessorFn<TGenerics['Row']>;
-    columnDef: ColumnDef<TGenerics>;
-    columnDefType: CoreColumnDefType;
-    getWidth: () => number;
-    columns: Column<TGenerics>[];
-    parent?: Column<TGenerics>;
-    getFlatColumns: () => Column<TGenerics>[];
-    getLeafColumns: () => Column<TGenerics>[];
-};
-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

@@ -0,0 +1,13 @@
+import { Cell, TableGenerics, TableInstance, Row, Column } from '../types';
+export declare type CellsRow<TGenerics extends TableGenerics> = {
+    getAllCells: () => Cell<TGenerics>[];
+    getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
+};
+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>;
+};
+export declare const Cells: {
+    createRow: <TGenerics extends TableGenerics>(row: Row<TGenerics>, instance: TableInstance<TGenerics>) => CellsRow<TGenerics>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => CellsInstance<TGenerics_1>;
+};

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

@@ -1,9 +1,10 @@
-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: ColumnSizing;
+    columnSizing: ColumnSizingState;
     columnSizingInfo: ColumnSizingInfoState;
 };
-export declare type ColumnSizing = Record<string, number>;
+export declare type ColumnSizingState = Record<string, number>;
 export declare type ColumnSizingInfoState = {
     startOffset: null | number;
     startSize: null | number;
@@ -16,24 +17,18 @@ export declare type ColumnResizeMode = 'onChange' | 'onEnd';
 export declare type ColumnSizingOptions = {
     enableColumnResizing?: boolean;
     columnResizeMode?: ColumnResizeMode;
-    onColumnSizingChange?: OnChangeFn<ColumnSizing>;
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
 };
 export declare type ColumnSizingDefaultOptions = {
     columnResizeMode: ColumnResizeMode;
-    onColumnSizingChange: OnChangeFn<ColumnSizing>;
+    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> = {
-    getColumnWidth: (columnId: string) => number;
-    setColumnSizing: (updater: Updater<ColumnSizing>) => void;
+    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;
@@ -41,18 +36,24 @@ 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;
+    getLeftTotalSize: () => number;
+    getCenterTotalSize: () => number;
+    getRightTotalSize: () => number;
 };
 export declare type ColumnSizingColumnDef = {
     enableResizing?: boolean;
     defaultCanResize?: boolean;
-    width?: number;
-    minWidth?: number;
-    maxWidth?: number;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
 };
 export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
     resetSize: () => void;
@@ -60,20 +61,13 @@ 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: {
-    width: number;
-    minWidth: number;
-    maxWidth: number;
-};
-export declare const ColumnSizing: {
-    getDefaultColumn: () => ColumnSizingColumnDef;
-    getInitialState: () => ColumnSizingTableState;
-    getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnSizingDefaultOptions;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ColumnSizingInstance<TGenerics_1>;
-    createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnSizingColumn<TGenerics_2>;
-    createHeader: <TGenerics_3 extends TableGenerics>(header: Header<TGenerics_3>, instance: TableInstance<TGenerics_3>) => ColumnSizingHeader<TGenerics_3>;
+    size: number;
+    minSize: number;
+    maxSize: number;
 };
+export declare const ColumnSizing: TableFeature;
 export declare function passiveEventSupported(): boolean;

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

@@ -0,0 +1,54 @@
+import { Cell, Column, Header, TableGenerics, TableInstance, Row, AccessorFn, ColumnDef, Renderable } from '../types';
+export declare type CoreColumnDefType = 'data' | 'display' | 'group';
+export declare type CoreColumnDef<TGenerics extends TableGenerics> = {
+    id: string;
+    accessorKey?: string & keyof TGenerics['Row'];
+    accessorFn?: AccessorFn<TGenerics['Row']>;
+    columns?: ColumnDef<TGenerics>[];
+    header?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        header: Header<TGenerics>;
+        column: Column<TGenerics>;
+    }>;
+    footer?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        header: Header<TGenerics>;
+        column: Column<TGenerics>;
+    }>;
+    cell?: Renderable<TGenerics, {
+        instance: TableInstance<TGenerics>;
+        row: Row<TGenerics>;
+        column: Column<TGenerics>;
+        cell: Cell<TGenerics>;
+        value: TGenerics['Value'];
+    }>;
+    meta?: TGenerics['ColumnMeta'];
+};
+export declare type CoreColumn<TGenerics extends TableGenerics> = {
+    id: string;
+    depth: number;
+    accessorFn?: AccessorFn<TGenerics['Row']>;
+    columnDef: ColumnDef<TGenerics>;
+    columnDefType: CoreColumnDefType;
+    columns: Column<TGenerics>[];
+    parent?: Column<TGenerics>;
+    getFlatColumns: () => Column<TGenerics>[];
+    getLeafColumns: () => Column<TGenerics>[];
+};
+export declare type ColumnsOptions<TGenerics extends TableGenerics> = {
+    columns: ColumnDef<TGenerics>[];
+    defaultColumn?: Partial<ColumnDef<TGenerics>>;
+};
+export declare type ColumnsInstance<TGenerics extends TableGenerics> = {
+    getDefaultColumn: () => Partial<ColumnDef<TGenerics>>;
+    getColumnDefs: () => ColumnDef<TGenerics>[];
+    createColumn: (columnDef: ColumnDef<TGenerics>, depth: number, parent?: Column<TGenerics>) => Column<TGenerics>;
+    getAllColumns: () => Column<TGenerics>[];
+    getAllFlatColumns: () => Column<TGenerics>[];
+    getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
+    getAllLeafColumns: () => Column<TGenerics>[];
+    getColumn: (columnId: string) => Column<TGenerics>;
+};
+export declare const Columns: {
+    createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnsInstance<TGenerics>;
+};

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,9 +9,10 @@ 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;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
     enableExpanded?: boolean;
@@ -22,10 +23,6 @@ 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;
     setExpanded: (updater: Updater<ExpandedState>) => void;
@@ -35,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;
@@ -47,6 +44,6 @@ export declare type ExpandedInstance<TGenerics extends TableGenerics> = {
 export declare const Expanding: {
     getInitialState: () => ExpandedTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ExpandedOptions<TGenerics>;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ExpandedInstance<TGenerics_1>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ExpandedInstance<TGenerics_1>;
     createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ExpandedRow;
 };

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

@@ -49,10 +49,12 @@ export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     filterFromLeafRows?: boolean;
     filterFns?: TGenerics['FilterFns'];
     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;
@@ -88,6 +90,6 @@ export declare const Filters: {
     getInitialState: () => FiltersTableState;
     getDefaultOptions: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => FiltersOptions<TGenerics_1>;
     createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => FiltersColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => FiltersInstance<TGenerics_3>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => FiltersInstance<TGenerics_3>;
 };
 export declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;

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,7 +43,7 @@ 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>;
@@ -51,6 +51,7 @@ export declare type ColumnDefaultOptions = {
     enableGrouping: boolean;
 };
 export declare type GroupingOptions<TGenerics extends TableGenerics> = {
+    manualGrouping?: boolean;
     aggregationFns?: TGenerics['AggregationFns'];
     onGroupingChange?: OnChangeFn<GroupingState>;
     autoResetGrouping?: boolean;
@@ -60,10 +61,6 @@ export declare type GroupingOptions<TGenerics extends TableGenerics> = {
     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;
@@ -74,7 +71,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>;
@@ -85,7 +82,7 @@ export declare const Grouping: {
     getInitialState: () => GroupingTableState;
     getDefaultOptions: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => GroupingOptions<TGenerics_1>;
     createColumn: <TGenerics_2 extends TableGenerics>(column: Column<TGenerics_2>, instance: TableInstance<TGenerics_2>) => GroupingColumn<TGenerics_2>;
-    getInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => GroupingInstance<TGenerics_3>;
+    createInstance: <TGenerics_3 extends TableGenerics>(instance: TableInstance<TGenerics_3>) => GroupingInstance<TGenerics_3>;
     createRow: <TGenerics_4 extends TableGenerics>(row: Row<TGenerics_4>, instance: TableInstance<TGenerics_4>) => GroupingRow;
     createCell: <TGenerics_5 extends TableGenerics>(cell: Cell<TGenerics_5>, column: Column<TGenerics_5>, row: Row<TGenerics_5>, instance: TableInstance<TGenerics_5>) => GroupingCell<TGenerics_5>;
     orderColumns: <TGenerics_6 extends TableGenerics>(leafColumns: Column<TGenerics_6>[], grouping: string[], groupedColumnMode?: GroupingColumnMode) => Column<TGenerics_6>[];

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

@@ -1,16 +1,10 @@
-import { Cell, Column, FooterGroupProps, FooterProps, Getter, Header, HeaderGroup, HeaderGroupProps, HeaderProps, TableGenerics, PropGetterValue, TableInstance, Row } from '../types';
-export declare type HeadersRow<TGenerics extends TableGenerics> = {
-    _getAllVisibleCells: () => Cell<TGenerics>[];
-    getVisibleCells: () => Cell<TGenerics>[];
-    getLeftVisibleCells: () => Cell<TGenerics>[];
-    getCenterVisibleCells: () => Cell<TGenerics>[];
-    getRightVisibleCells: () => Cell<TGenerics>[];
-};
+import { Column, Header, HeaderGroup, TableGenerics, TableInstance } from '../types';
 export declare type HeadersInstance<TGenerics extends TableGenerics> = {
     createHeader: (column: Column<TGenerics>, options: {
         id?: string;
         isPlaceholder?: boolean;
         placeholderId?: string;
+        index: number;
         depth: number;
     }) => Header<TGenerics>;
     getHeaderGroups: () => HeaderGroup<TGenerics>[];
@@ -30,14 +24,8 @@ 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>;
-    getTotalWidth: () => number;
 };
 export declare const Headers: {
-    createRow: <TGenerics extends TableGenerics>(row: Row<TGenerics>, instance: TableInstance<TGenerics>) => HeadersRow<TGenerics>;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => HeadersInstance<TGenerics_1>;
+    createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => HeadersInstance<TGenerics>;
 };
 export declare function buildHeaderGroups<TGenerics extends TableGenerics>(allColumns: Column<TGenerics>[], columnsToGroup: Column<TGenerics>[], instance: TableInstance<TGenerics>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TGenerics>[];

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

@@ -17,5 +17,5 @@ export declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
 export declare const Ordering: {
     getInitialState: () => ColumnOrderTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnOrderDefaultOptions;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ColumnOrderInstance<TGenerics_1>;
+    createInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => ColumnOrderInstance<TGenerics_1>;
 };

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,7 +7,11 @@ 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>;
     autoResetPageIndex?: boolean;
     getPaginationRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
@@ -35,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;
-    getInstance: <TGenerics_1 extends TableGenerics>(instance: TableInstance<TGenerics_1>) => PaginationInstance<TGenerics_1>;
-};
+export declare const Pagination: TableFeature;

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

@@ -1,5 +1,5 @@
-import { OnChangeFn, Updater, TableInstance, Column, TableGenerics } from '../types';
-declare type ColumnPinningPosition = false | 'left' | 'right';
+import { OnChangeFn, Updater, TableInstance, Column, TableGenerics, Row, Cell } from '../types';
+export declare type ColumnPinningPosition = false | 'left' | 'right';
 export declare type ColumnPinningState = {
     left?: string[];
     right?: string[];
@@ -24,6 +24,16 @@ export declare type ColumnPinningColumn = {
     getIsPinned: () => ColumnPinningPosition;
     pin: (position: ColumnPinningPosition) => void;
 };
+export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
+    getLeftVisibleCells: () => Cell<TGenerics>[];
+    getCenterVisibleCells: () => Cell<TGenerics>[];
+    getRightVisibleCells: () => Cell<TGenerics>[];
+};
+export declare type ColumnPinningCell<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;
@@ -32,11 +42,15 @@ export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
     getColumnIsPinned: (columnId: string) => ColumnPinningPosition;
     getColumnPinnedIndex: (columnId: string) => number;
     getIsSomeColumnsPinned: () => boolean;
+    getLeftLeafColumns: () => Column<TGenerics>[];
+    getRightLeafColumns: () => Column<TGenerics>[];
+    getCenterLeafColumns: () => Column<TGenerics>[];
 };
 export declare const Pinning: {
     getInitialState: () => ColumnPinningTableState;
     getDefaultOptions: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => ColumnPinningDefaultOptions;
     createColumn: <TGenerics_1 extends TableGenerics>(column: Column<TGenerics_1>, instance: TableInstance<TGenerics_1>) => ColumnPinningColumn;
-    getInstance: <TGenerics_2 extends TableGenerics>(instance: TableInstance<TGenerics_2>) => ColumnPinningInstance<TGenerics_2>;
+    createRow: <TGenerics_2 extends TableGenerics>(row: Row<TGenerics_2>, instance: TableInstance<TGenerics_2>) => ColumnPinningRow<TGenerics_2>;
+    createCell: <TGenerics_3 extends TableGenerics>(cell: Cell<TGenerics_3>, instance: TableInstance<TGenerics_3>) => ColumnPinningCell<TGenerics_3>;
+    createInstance: <TGenerics_4 extends TableGenerics>(instance: TableInstance<TGenerics_4>) => ColumnPinningInstance<TGenerics_4>;
 };
-export {};