@tanstack/table-core 8.0.0-alpha.82 → 8.0.0-alpha.85

package/build/types/aggregationFns.d.ts

@@ -1,22 +1,13 @@
+import { AggregationFn } from './features/Grouping';
 export declare const aggregationFns: {
-    sum: typeof sum;
-    min: typeof min;
-    max: typeof max;
-    extent: typeof extent;
-    mean: typeof mean;
-    median: typeof median;
-    unique: typeof unique;
-    uniqueCount: typeof uniqueCount;
-    count: typeof count;
+    sum: AggregationFn<any>;
+    min: AggregationFn<any>;
+    max: AggregationFn<any>;
+    extent: AggregationFn<any>;
+    mean: AggregationFn<any>;
+    median: AggregationFn<any>;
+    unique: AggregationFn<any>;
+    uniqueCount: AggregationFn<any>;
+    count: AggregationFn<any>;
 };
 export declare type BuiltInAggregationFn = keyof typeof aggregationFns;
-declare function sum(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number;
-declare function min(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number | undefined;
-declare function max(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number | undefined;
-declare function extent(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): (number | undefined)[];
-export declare function mean(getLeafValues: () => unknown[]): number | undefined;
-declare function median(getLeafValues: () => unknown[]): number | undefined;
-declare function unique<T>(getLeafValues: () => T[]): T[];
-declare function uniqueCount(getLeafValues: () => unknown[]): number;
-declare function count(getLeafValues: () => unknown[]): number;
-export {};

package/build/types/core/cell.d.ts

@@ -0,0 +1,9 @@
+import { Cell, Column, Row, TableGenerics, TableInstance } from '../types';
+export declare type CoreCell<TGenerics extends TableGenerics> = {
+    id: string;
+    getValue: () => TGenerics['Value'];
+    row: Row<TGenerics>;
+    column: Column<TGenerics>;
+    renderCell: () => string | null | TGenerics['Rendered'];
+};
+export declare function createCell<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, row: Row<TGenerics>, column: Column<TGenerics>, columnId: string): Cell<TGenerics>;

package/build/types/{features/Columns.d.ts → core/column.d.ts}

@@ -35,20 +35,6 @@ export declare type CoreColumn<TGenerics extends TableGenerics> = {
     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>;
-};
+export declare function createColumn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, columnDef: ColumnDef<TGenerics> & {
+    columnDefType?: CoreColumnDefType;
+}, depth: number, parent?: Column<TGenerics>): Column<TGenerics>;

package/build/types/{features/Headers.d.ts → core/headers.d.ts}

@@ -1,12 +1,30 @@
 import { Column, Header, HeaderGroup, TableGenerics, TableInstance } from '../types';
+import { TableFeature } from './instance';
+export declare type CoreHeaderGroup<TGenerics extends TableGenerics> = {
+    id: string;
+    depth: number;
+    headers: Header<TGenerics>[];
+};
+export declare type CoreHeader<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    depth: number;
+    column: Column<TGenerics>;
+    headerGroup: HeaderGroup<TGenerics>;
+    subHeaders: Header<TGenerics>[];
+    colSpan: number;
+    rowSpan: number;
+    getLeafHeaders: () => Header<TGenerics>[];
+    isPlaceholder: boolean;
+    placeholderId?: string;
+    renderHeader: (options?: {
+        renderPlaceholder?: boolean;
+    }) => string | null | TGenerics['Rendered'];
+    renderFooter: (options?: {
+        renderPlaceholder?: boolean;
+    }) => string | null | TGenerics['Rendered'];
+};
 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>[];
     getLeftHeaderGroups: () => HeaderGroup<TGenerics>[];
     getCenterHeaderGroups: () => HeaderGroup<TGenerics>[];
@@ -23,9 +41,6 @@ export declare type HeadersInstance<TGenerics extends TableGenerics> = {
     getLeftLeafHeaders: () => Header<TGenerics>[];
     getCenterLeafHeaders: () => Header<TGenerics>[];
     getRightLeafHeaders: () => Header<TGenerics>[];
-    getHeader: (id: string) => Header<TGenerics>;
-};
-export declare const Headers: {
-    createInstance: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>) => HeadersInstance<TGenerics>;
 };
+export declare const Headers: TableFeature;
 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/core/instance.d.ts

@@ -0,0 +1,57 @@
+import { RequiredKeys } from '../utils';
+import { Updater, TableOptionsResolved, TableState, TableInstance, Renderable, TableGenerics, InitialTableState, Row, Column, RowModel, ColumnDef } from '../types';
+export declare type TableFeature = {
+    getDefaultOptions?: (instance: any) => any;
+    getInitialState?: (initialState?: InitialTableState) => any;
+    createInstance?: (instance: any) => any;
+    getDefaultColumnDef?: () => any;
+    createColumn?: (column: any, instance: any) => any;
+    createHeader?: (column: any, instance: any) => any;
+    createCell?: (cell: any, column: any, row: any, instance: any) => any;
+    createRow?: (row: any, instance: any) => any;
+};
+export declare type CoreTableState = {};
+export declare type CoreOptions<TGenerics extends TableGenerics> = {
+    data: TGenerics['Row'][];
+    state: Partial<TableState>;
+    onStateChange: (updater: Updater<TableState>) => void;
+    render: TGenerics['Renderer'];
+    debugAll?: boolean;
+    debugTable?: boolean;
+    debugHeaders?: boolean;
+    debugColumns?: boolean;
+    debugRows?: boolean;
+    initialState?: InitialTableState;
+    autoResetAll?: boolean;
+    mergeOptions?: <T>(defaultOptions: T, options: Partial<T>) => T;
+    meta?: TGenerics['TableMeta'];
+    getCoreRowModel: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+    getSubRows?: (originalRow: TGenerics['Row'], index: number) => undefined | TGenerics['Row'][];
+    getRowId?: (originalRow: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    columns: ColumnDef<TGenerics>[];
+    defaultColumn?: Partial<ColumnDef<TGenerics>>;
+};
+export declare type CoreInstance<TGenerics extends TableGenerics> = {
+    initialState: TableState;
+    reset: () => void;
+    options: RequiredKeys<TableOptionsResolved<TGenerics>, 'state'>;
+    setOptions: (newOptions: Updater<TableOptionsResolved<TGenerics>>) => void;
+    getState: () => TableState;
+    setState: (updater: Updater<TableState>) => void;
+    _features: readonly TableFeature[];
+    _queue: (cb: () => void) => void;
+    _render: <TProps>(template: Renderable<TGenerics, TProps>, props: TProps) => string | null | TGenerics['Rendered'];
+    _getRowId: (_: TGenerics['Row'], index: number, parent?: Row<TGenerics>) => string;
+    getCoreRowModel: () => RowModel<TGenerics>;
+    _getCoreRowModel?: () => RowModel<TGenerics>;
+    getRowModel: () => RowModel<TGenerics>;
+    getRow: (id: string) => Row<TGenerics>;
+    _getDefaultColumnDef: () => Partial<ColumnDef<TGenerics>>;
+    _getColumnDefs: () => ColumnDef<TGenerics>[];
+    _getAllFlatColumnsById: () => Record<string, Column<TGenerics>>;
+    getAllColumns: () => Column<TGenerics>[];
+    getAllFlatColumns: () => Column<TGenerics>[];
+    getAllLeafColumns: () => Column<TGenerics>[];
+    getColumn: (columnId: string) => Column<TGenerics>;
+};
+export declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptionsResolved<TGenerics>): TableInstance<TGenerics>;

package/build/types/core/row.d.ts

@@ -0,0 +1,15 @@
+import { Cell, Row, TableGenerics, TableInstance } from '../types';
+export declare type CoreRow<TGenerics extends TableGenerics> = {
+    id: string;
+    index: number;
+    original?: TGenerics['Row'];
+    depth: number;
+    _valuesCache: Record<string, any>;
+    getValue: (columnId: string) => any;
+    subRows: Row<TGenerics>[];
+    getLeafRows: () => Row<TGenerics>[];
+    originalSubRows?: TGenerics['Row'][];
+    getAllCells: () => Cell<TGenerics>[];
+    _getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>;
+};
+export declare const createRow: <TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, id: string, original: TGenerics["Row"] | undefined, rowIndex: number, depth: number, subRows?: Row<TGenerics>[] | undefined) => Row<TGenerics>;

package/build/types/createTable.d.ts

@@ -1,7 +1,7 @@
 import { CustomFilterFns, FilterFn } from './features/Filters';
 import { AggregationFn, CustomAggregationFns } from './features/Grouping';
 import { CustomSortingFns, SortingFn } from './features/Sorting';
-import { ColumnDef, AccessorFn, AnyRender, TableGenerics, TableOptions } from './types';
+import { ColumnDef, AccessorFn, AnyRender, TableGenerics, TableOptionsResolved, 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<{
@@ -9,11 +9,10 @@ export declare type CreateTableOptions<TRender extends AnyRender, TFilterFns ext
     filterFns?: TFilterFns;
     sortingFns?: TSortingFns;
     aggregationFns?: TAggregationFns;
-} & Omit<TableOptions<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
+} & Omit<TableOptionsResolved<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
 export declare type Table<TGenerics extends TableGenerics> = {
     generics: TGenerics;
-    options: Partial<TableOptions<TGenerics>>;
-    setGenerics: <T extends TableGenerics>() => Table<T>;
+    options: Partial<TableOptionsResolved<TGenerics>>;
     setRowType: <TRow>() => Table<Overwrite<TGenerics, {
         Row: TRow;
     }>>;
@@ -54,6 +53,7 @@ export declare type Table<TGenerics extends TableGenerics> = {
         accessorKey?: never;
         columns?: ColumnDef<any>[];
     }>) => ColumnDef<TGenerics>;
+    createOptions: (options: TableOptions<TGenerics>) => TableOptions<TGenerics>;
 };
 export declare function createTableFactory<TRenderer extends AnyRender>(opts: {
     render: TRenderer;

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

@@ -1,4 +1,5 @@
-import { OnChangeFn, TableGenerics, Updater, TableFeature } from '../types';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, Updater } from '../types';
 import { ColumnPinningPosition } from './Pinning';
 export declare type ColumnSizingTableState = {
     columnSizing: ColumnSizingState;

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

@@ -1,5 +1,6 @@
 import { RowModel } from '..';
-import { OnChangeFn, TableGenerics, TableInstance, Row, Updater, TableFeature } from '../types';
+import { TableFeature } from '../core/instance';
+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 = {

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

@@ -1,6 +1,7 @@
 import { RowModel } from '..';
+import { TableFeature } from '../core/instance';
 import { BuiltInFilterFn } from '../filterFns';
-import { Column, OnChangeFn, TableGenerics, TableInstance, Row, Updater, TableFeature } from '../types';
+import { Column, OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 import { Overwrite } from '../utils';
 export declare type FiltersTableState = {
     columnFilters: ColumnFiltersState;
@@ -31,7 +32,6 @@ export declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
     }>>;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
-    enableFaceting?: boolean;
 };
 export declare type FiltersColumn<TGenerics extends TableGenerics> = {
     filterFn: FilterFnOption<Overwrite<TGenerics, {
@@ -55,7 +55,6 @@ export declare type FiltersColumn<TGenerics extends TableGenerics> = {
 export declare type FiltersRow<TGenerics extends TableGenerics> = {
     columnFilters: Record<string, boolean>;
     columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
-    subRowsByFacetId: Record<string, Row<TGenerics>[]>;
 };
 export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     enableFilters?: boolean;

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

@@ -1,19 +1,19 @@
 import { RowModel } from '..';
 import { BuiltInAggregationFn } from '../aggregationFns';
-import { Cell, Column, OnChangeFn, TableInstance, Row, Updater, Renderable, TableGenerics, TableFeature } from '../types';
+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 TableGenerics> = (getLeafValues: () => TGenerics['Value'][], getChildValues: () => TGenerics['Value'][]) => 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 GroupingTableState = {
     grouping: GroupingState;
 };
+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;
     aggregatedCell?: Renderable<TGenerics, {
         instance: TableInstance<TGenerics>;
         row: Row<TGenerics>;
@@ -32,14 +32,14 @@ export declare type GroupingColumn<TGenerics extends TableGenerics> = {
     getGroupedIndex: () => number;
     toggleGrouping: () => void;
     getToggleGroupingHandler: () => () => void;
-    getColumnAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
-    getColumnAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getAggregationFn: () => AggregationFn<TGenerics> | undefined;
 };
 export declare type GroupingRow = {
     groupingColumnId?: string;
     groupingValue?: any;
     getIsGrouped: () => boolean;
-    groupingValuesCache: Record<string, any>;
+    _groupingValuesCache: Record<string, any>;
 };
 export declare type GroupingCell<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
@@ -56,7 +56,6 @@ export declare type GroupingOptions<TGenerics extends TableGenerics> = {
     aggregationFns?: TGenerics['AggregationFns'];
     onGroupingChange?: OnChangeFn<GroupingState>;
     enableGrouping?: boolean;
-    enableGroupingRemoval?: boolean;
     getGroupedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
     groupedColumnMode?: false | 'reorder' | 'remove';
 };

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

@@ -1,4 +1,5 @@
-import { OnChangeFn, Updater, Column, TableGenerics, TableFeature } from '../types';
+import { OnChangeFn, Updater, Column, TableGenerics } from '../types';
+import { TableFeature } from '../core/instance';
 export declare type ColumnOrderTableState = {
     columnOrder: ColumnOrderState;
 };

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

@@ -1,4 +1,5 @@
-import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater, TableFeature } from '../types';
+import { TableFeature } from '../core/instance';
+import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater } from '../types';
 export declare type PaginationState = {
     pageIndex: number;
     pageSize: number;

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

@@ -1,4 +1,5 @@
-import { OnChangeFn, Updater, Column, TableGenerics, Cell, TableFeature } from '../types';
+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[];
@@ -31,7 +32,7 @@ export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
 export declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
     setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
     resetColumnPinning: (defaultState?: boolean) => void;
-    getIsSomeColumnsPinned: () => boolean;
+    getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
     getLeftLeafColumns: () => Column<TGenerics>[];
     getRightLeafColumns: () => Column<TGenerics>[];
     getCenterLeafColumns: () => Column<TGenerics>[];

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

@@ -1,4 +1,5 @@
-import { OnChangeFn, TableGenerics, TableInstance, Row, RowModel, Updater, TableFeature } 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;

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

@@ -1,6 +1,7 @@
 import { RowModel } from '..';
+import { TableFeature } from '../core/instance';
 import { BuiltInSortingFn } from '../sortingFns';
-import { OnChangeFn, TableGenerics, TableInstance, Row, Updater, TableFeature } from '../types';
+import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
 import { Overwrite } from '../utils';
 export declare type SortDirection = 'asc' | 'desc';
 export declare type ColumnSort = {

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

@@ -1,4 +1,5 @@
-import { Cell, Column, OnChangeFn, TableGenerics, Updater, TableFeature } from '../types';
+import { TableFeature } from '../core/instance';
+import { Cell, Column, OnChangeFn, TableGenerics, Updater } from '../types';
 export declare type VisibilityOptions = {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;

package/build/types/index.d.ts

@@ -1,12 +1,14 @@
-export * from './core';
+export * from './core/instance';
 export * from './types';
 export * from './createTable';
+export * from './core/column';
+export * from './core/headers';
+export * from './core/row';
 export * from './features/ColumnSizing';
 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';

package/build/types/sortingFns.d.ts

@@ -11,8 +11,8 @@ export declare const sortingFns: {
 export declare type BuiltInSortingFn = keyof typeof sortingFns;
 declare function alphanumeric<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
 declare function alphanumericCaseSensitive<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
-declare function text<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 0 | 1 | -1;
-declare function textCaseSensitive<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 0 | 1 | -1;
-declare function datetime<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 0 | 1 | -1;
-declare function basic<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 0 | 1 | -1;
+declare function text<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
+declare function textCaseSensitive<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
+declare function datetime<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
+declare function basic<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
 export {};

package/build/types/types.d.ts

@@ -1,9 +1,9 @@
-import { CoreOptions, CoreTableState, CoreInstance } from './core';
-import { ColumnsOptions, CoreColumn, CoreColumnDef } from './features/Columns';
+import { CoreOptions, CoreTableState, CoreInstance } from './core/instance';
+import { CoreColumn, CoreColumnDef } from './core/column';
 import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
 import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
 import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState } from './features/Pinning';
-import { HeadersInstance } from './features/Headers';
+import { CoreHeader, CoreHeaderGroup, HeadersInstance } from './core/headers';
 import { FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersRow, FiltersTableState } from './features/Filters';
 import { SortingColumn, SortingColumnDef, SortingInstance, SortingOptions, SortingTableState } from './features/Sorting';
 import { GroupingCell, GroupingColumn, GroupingColumnDef, GroupingInstance, GroupingOptions, GroupingRow, GroupingTableState } from './features/Grouping';
@@ -11,9 +11,9 @@ import { ExpandedInstance, ExpandedOptions, ExpandedTableState, ExpandedRow } fr
 import { ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingHeader, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingTableState } from './features/ColumnSizing';
 import { PaginationInitialTableState, PaginationInstance, PaginationOptions, PaginationTableState } from './features/Pagination';
 import { RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionTableState } from './features/RowSelection';
-import { ColumnsInstance } from './features/Columns';
-import { CellsInstance, CellsRow } from './features/Cells';
-import { CoreRow, RowsInstance, RowsOptions } from './features/Rows';
+import { CoreRow } from './core/row';
+import { PartialKeys } from './utils';
+import { CoreCell } from './core/cell';
 export declare type Updater<T> = T | ((old: T) => T);
 export declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
 export declare type TableGenerics = {
@@ -29,21 +29,12 @@ export declare type TableGenerics = {
     FilterMeta?: any;
 };
 export declare type AnyRender = (Comp: any, props: any) => any;
-export declare type TableFeature = {
-    getDefaultOptions?: (instance: any) => any;
-    getInitialState?: (initialState?: InitialTableState) => any;
-    createInstance?: (instance: any) => any;
-    getDefaultColumn?: () => any;
-    createColumn?: (column: any, instance: any) => any;
-    createHeader?: (column: any, instance: any) => any;
-    createCell?: (cell: any, column: any, row: any, instance: any) => any;
-    createRow?: (row: any, instance: any) => any;
-};
-export declare type TableInstance<TGenerics extends TableGenerics> = CoreInstance<TGenerics> & ColumnsInstance<TGenerics> & RowsInstance<TGenerics> & CellsInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & HeadersInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
-export declare type TableOptions<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & ColumnsOptions<TGenerics> & RowsOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
+export declare type TableInstance<TGenerics extends TableGenerics> = CoreInstance<TGenerics> & HeadersInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
+export declare type TableOptionsResolved<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
+export declare type TableOptions<TGenerics extends TableGenerics> = Omit<PartialKeys<TableOptionsResolved<TGenerics>, 'state' | 'onStateChange'>, 'render'>;
 export declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
 export declare type InitialTableState = Partial<CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationInitialTableState & RowSelectionTableState>;
-export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & CellsRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & FiltersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
+export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & FiltersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
 export declare type RowValues = {
     [key: string]: any;
 };
@@ -55,40 +46,8 @@ export declare type RowModel<TGenerics extends TableGenerics> = {
 export declare type AccessorFn<TData> = (originalRow: TData, index: number) => any;
 export declare type Renderable<TGenerics extends TableGenerics, TProps> = string | ((props: TProps) => TGenerics['Rendered']);
 export declare type ColumnDef<TGenerics extends TableGenerics> = CoreColumnDef<TGenerics> & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TGenerics> & SortingColumnDef<TGenerics> & GroupingColumnDef<TGenerics> & ColumnSizingColumnDef;
-export declare type Column<TGenerics extends TableGenerics> = ColumnDef<TGenerics> & CoreColumn<TGenerics> & ColumnVisibilityColumn & ColumnPinningColumn & FiltersColumn<TGenerics> & SortingColumn<TGenerics> & GroupingColumn<TGenerics> & ColumnSizingColumn<TGenerics>;
+export declare type Column<TGenerics extends TableGenerics> = CoreColumn<TGenerics> & ColumnVisibilityColumn & ColumnPinningColumn & FiltersColumn<TGenerics> & SortingColumn<TGenerics> & GroupingColumn<TGenerics> & ColumnSizingColumn<TGenerics>;
 export declare type Cell<TGenerics extends TableGenerics> = CoreCell<TGenerics> & GroupingCell<TGenerics>;
-export declare type CoreCell<TGenerics extends TableGenerics> = {
-    id: string;
-    rowId: string;
-    columnId: string;
-    getValue: () => TGenerics['Value'];
-    row: Row<TGenerics>;
-    column: Column<TGenerics>;
-    renderCell: () => string | null | TGenerics['Rendered'];
-};
 export declare type Header<TGenerics extends TableGenerics> = CoreHeader<TGenerics> & ColumnSizingHeader<TGenerics>;
-export declare type CoreHeader<TGenerics extends TableGenerics> = {
-    id: string;
-    index: number;
-    depth: number;
-    column: Column<TGenerics>;
-    headerGroup: HeaderGroup<TGenerics>;
-    subHeaders: Header<TGenerics>[];
-    colSpan?: number;
-    rowSpan?: number;
-    getLeafHeaders: () => Header<TGenerics>[];
-    isPlaceholder?: boolean;
-    placeholderId?: string;
-    renderHeader: (options?: {
-        renderPlaceholder?: boolean;
-    }) => string | null | TGenerics['Rendered'];
-    renderFooter: (options?: {
-        renderPlaceholder?: boolean;
-    }) => string | null | TGenerics['Rendered'];
-};
-export declare type HeaderGroup<TGenerics extends TableGenerics> = {
-    id: string;
-    depth: number;
-    headers: Header<TGenerics>[];
-};
+export declare type HeaderGroup<TGenerics extends TableGenerics> = CoreHeaderGroup<TGenerics>;
 export declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];