@tanstack/table-core 8.0.13 → 8.0.14

package/build/types/index.d.ts

@@ -8,45 +8,102 @@
  *
  * @license MIT
  */
+declare type CoreCell<TData extends RowData> = {
+    id: string;
+    getValue: () => any;
+    renderValue: () => unknown;
+    row: Row<TData>;
+    column: Column<TData>;
+    getContext: () => {
+        table: Table<TData>;
+        column: Column<TData>;
+        row: Row<TData>;
+        cell: Cell<TData>;
+        getValue: () => any;
+        renderValue: () => any;
+    };
+};
+
+declare type CoreHeaderGroup<TData extends RowData> = {
+    id: string;
+    depth: number;
+    headers: Header<TData>[];
+};
+declare type CoreHeader<TData extends RowData> = {
+    id: string;
+    index: number;
+    depth: number;
+    column: Column<TData>;
+    headerGroup: HeaderGroup<TData>;
+    subHeaders: Header<TData>[];
+    colSpan: number;
+    rowSpan: number;
+    getLeafHeaders: () => Header<TData>[];
+    isPlaceholder: boolean;
+    placeholderId?: string;
+    getContext: () => {
+        table: Table<TData>;
+        header: Header<TData>;
+        column: Column<TData>;
+    };
+};
+declare type HeadersInstance<TData extends RowData> = {
+    getHeaderGroups: () => HeaderGroup<TData>[];
+    getLeftHeaderGroups: () => HeaderGroup<TData>[];
+    getCenterHeaderGroups: () => HeaderGroup<TData>[];
+    getRightHeaderGroups: () => HeaderGroup<TData>[];
+    getFooterGroups: () => HeaderGroup<TData>[];
+    getLeftFooterGroups: () => HeaderGroup<TData>[];
+    getCenterFooterGroups: () => HeaderGroup<TData>[];
+    getRightFooterGroups: () => HeaderGroup<TData>[];
+    getFlatHeaders: () => Header<TData>[];
+    getLeftFlatHeaders: () => Header<TData>[];
+    getCenterFlatHeaders: () => Header<TData>[];
+    getRightFlatHeaders: () => Header<TData>[];
+    getLeafHeaders: () => Header<TData>[];
+    getLeftLeafHeaders: () => Header<TData>[];
+    getCenterLeafHeaders: () => Header<TData>[];
+    getRightLeafHeaders: () => Header<TData>[];
+};
+declare const Headers: TableFeature;
+declare function buildHeaderGroups<TData extends RowData>(allColumns: Column<TData>[], columnsToGroup: Column<TData>[], table: Table<TData>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TData>[];
+
 declare type CoreColumnDefType = 'data' | 'display' | 'group';
-declare type CoreColumnDef<TGenerics extends TableGenerics> = {
+declare type CoreColumnDefBase<TData extends RowData> = {
+    columns?: ColumnDef<TData>[];
+    header?: ColumnDefTemplate<ReturnType<CoreHeader<TData>['getContext']>>;
+    footer?: ColumnDefTemplate<ReturnType<CoreHeader<TData>['getContext']>>;
+    cell?: ColumnDefTemplate<ReturnType<CoreCell<TData>['getContext']>>;
+    meta?: unknown;
+};
+declare type CoreColumnDefDisplay<TData extends RowData> = CoreColumnDefBase<TData> & {
     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>;
-        getValue: () => TGenerics['Value'];
-    }>;
-    meta?: TGenerics['ColumnMeta'];
-};
-declare type CoreColumn<TGenerics extends TableGenerics> = {
+};
+declare type CoreColumnDefDisplayWithStringHeader<TData extends RowData> = CoreColumnDefBase<TData> & {
+    header: string;
+    id?: string;
+};
+declare type CoreColumnDefAccessorFn<TData extends RowData> = CoreColumnDefBase<TData> & {
+    accessorFn: AccessorFn<TData>;
+    id: string;
+};
+declare type CoreColumnDefAccessorKey<TData extends RowData> = CoreColumnDefBase<TData> & {
+    accessorKey: keyof TData;
+    id?: string;
+};
+declare type CoreColumnDef<TData extends RowData> = CoreColumnDefDisplay<TData> | CoreColumnDefDisplayWithStringHeader<TData> | CoreColumnDefAccessorFn<TData> | CoreColumnDefAccessorKey<TData>;
+declare type CoreColumnDefResolved<TData extends RowData> = Partial<UnionToIntersection<CoreColumnDef<TData>>>;
+declare type CoreColumn<TData extends RowData> = {
     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>[];
-};
-declare function createColumn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, columnDef: ColumnDef<TGenerics> & {
-    columnDefType?: CoreColumnDefType;
-}, depth: number, parent?: Column<TGenerics>): Column<TGenerics>;
+    accessorFn?: AccessorFn<TData>;
+    columnDef: ColumnDef<TData>;
+    columns: Column<TData>[];
+    parent?: Column<TData>;
+    getFlatColumns: () => Column<TData>[];
+    getLeafColumns: () => Column<TData>[];
+};
+declare function createColumn<TData extends RowData>(table: Table<TData>, columnDef: ColumnDef<TData>, depth: number, parent?: Column<TData>): Column<TData>;
 
 declare type VisibilityState = Record<string, boolean>;
 declare type VisibilityTableState = {
@@ -59,12 +116,12 @@ declare type VisibilityOptions = {
 declare type VisibilityDefaultOptions = {
     onColumnVisibilityChange: OnChangeFn<VisibilityState>;
 };
-declare type VisibilityInstance<TGenerics extends TableGenerics> = {
-    getVisibleFlatColumns: () => Column<TGenerics>[];
-    getVisibleLeafColumns: () => Column<TGenerics>[];
-    getLeftVisibleLeafColumns: () => Column<TGenerics>[];
-    getRightVisibleLeafColumns: () => Column<TGenerics>[];
-    getCenterVisibleLeafColumns: () => Column<TGenerics>[];
+declare type VisibilityInstance<TData extends RowData> = {
+    getVisibleFlatColumns: () => Column<TData>[];
+    getVisibleLeafColumns: () => Column<TData>[];
+    getLeftVisibleLeafColumns: () => Column<TData>[];
+    getRightVisibleLeafColumns: () => Column<TData>[];
+    getCenterVisibleLeafColumns: () => Column<TData>[];
     setColumnVisibility: (updater: Updater<VisibilityState>) => void;
     resetColumnVisibility: (defaultState?: boolean) => void;
     toggleAllColumnsVisible: (value?: boolean) => void;
@@ -75,9 +132,9 @@ declare type VisibilityInstance<TGenerics extends TableGenerics> = {
 declare type VisibilityColumnDef = {
     enableHiding?: boolean;
 };
-declare type VisibilityRow<TGenerics extends TableGenerics> = {
-    _getAllVisibleCells: () => Cell<TGenerics>[];
-    getVisibleCells: () => Cell<TGenerics>[];
+declare type VisibilityRow<TData extends RowData> = {
+    _getAllVisibleCells: () => Cell<TData>[];
+    getVisibleCells: () => Cell<TData>[];
 };
 declare type VisibilityColumn = {
     getCanHide: () => boolean;
@@ -97,10 +154,10 @@ declare type ColumnOrderOptions = {
 declare type ColumnOrderDefaultOptions = {
     onColumnOrderChange: OnChangeFn<ColumnOrderState>;
 };
-declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
+declare type ColumnOrderInstance<TData extends RowData> = {
     setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
     resetColumnOrder: (defaultState?: boolean) => void;
-    _getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
+    _getOrderColumnsFn: () => (columns: Column<TData>[]) => Column<TData>[];
 };
 declare const Ordering: TableFeature;
 
@@ -128,66 +185,21 @@ declare type ColumnPinningColumn = {
     getIsPinned: () => ColumnPinningPosition;
     pin: (position: ColumnPinningPosition) => void;
 };
-declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
-    getLeftVisibleCells: () => Cell<TGenerics>[];
-    getCenterVisibleCells: () => Cell<TGenerics>[];
-    getRightVisibleCells: () => Cell<TGenerics>[];
+declare type ColumnPinningRow<TData extends RowData> = {
+    getLeftVisibleCells: () => Cell<TData>[];
+    getCenterVisibleCells: () => Cell<TData>[];
+    getRightVisibleCells: () => Cell<TData>[];
 };
-declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
+declare type ColumnPinningInstance<TData extends RowData> = {
     setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
     resetColumnPinning: (defaultState?: boolean) => void;
     getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
-    getLeftLeafColumns: () => Column<TGenerics>[];
-    getRightLeafColumns: () => Column<TGenerics>[];
-    getCenterLeafColumns: () => Column<TGenerics>[];
+    getLeftLeafColumns: () => Column<TData>[];
+    getRightLeafColumns: () => Column<TData>[];
+    getCenterLeafColumns: () => Column<TData>[];
 };
 declare const Pinning: TableFeature;
 
-declare type CoreHeaderGroup<TGenerics extends TableGenerics> = {
-    id: string;
-    depth: number;
-    headers: Header<TGenerics>[];
-};
-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'];
-};
-declare type HeadersInstance<TGenerics extends TableGenerics> = {
-    getHeaderGroups: () => HeaderGroup<TGenerics>[];
-    getLeftHeaderGroups: () => HeaderGroup<TGenerics>[];
-    getCenterHeaderGroups: () => HeaderGroup<TGenerics>[];
-    getRightHeaderGroups: () => HeaderGroup<TGenerics>[];
-    getFooterGroups: () => HeaderGroup<TGenerics>[];
-    getLeftFooterGroups: () => HeaderGroup<TGenerics>[];
-    getCenterFooterGroups: () => HeaderGroup<TGenerics>[];
-    getRightFooterGroups: () => HeaderGroup<TGenerics>[];
-    getFlatHeaders: () => Header<TGenerics>[];
-    getLeftFlatHeaders: () => Header<TGenerics>[];
-    getCenterFlatHeaders: () => Header<TGenerics>[];
-    getRightFlatHeaders: () => Header<TGenerics>[];
-    getLeafHeaders: () => Header<TGenerics>[];
-    getLeftLeafHeaders: () => Header<TGenerics>[];
-    getCenterLeafHeaders: () => Header<TGenerics>[];
-    getRightLeafHeaders: () => Header<TGenerics>[];
-};
-declare const Headers: TableFeature;
-declare function buildHeaderGroups<TGenerics extends TableGenerics>(allColumns: Column<TGenerics>[], columnsToGroup: Column<TGenerics>[], instance: TableInstance<TGenerics>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TGenerics>[];
-
 declare const filterFns: {
     includesString: FilterFn<any>;
     includesStringSensitive: FilterFn<any>;
@@ -210,35 +222,33 @@ declare type ColumnFilter = {
     id: string;
     value: unknown;
 };
-declare type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+declare type ResolvedColumnFilter<TData extends RowData> = {
     id: string;
     resolvedValue: unknown;
-    filterFn: FilterFn<TGenerics>;
-};
-declare type FilterFn<TGenerics extends TableGenerics> = {
-    (row: Row<TGenerics>, columnId: string, filterValue: any, addMeta: (meta: TGenerics['FilterMeta']) => void): boolean;
-    resolveFilterValue?: TransformFilterValueFn<TGenerics>;
-    autoRemove?: ColumnFilterAutoRemoveTestFn<TGenerics>;
-};
-declare type TransformFilterValueFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => unknown;
-declare type ColumnFilterAutoRemoveTestFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => boolean;
-declare type CustomFilterFns<TGenerics extends TableGenerics> = Record<string, FilterFn<TGenerics>>;
-declare type FilterFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInFilterFn | keyof TGenerics['FilterFns'] | FilterFn<TGenerics>;
-declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
-    filterFn?: FilterFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
+    filterFn: FilterFn<TData>;
+};
+declare type FilterFn<TData extends RowData> = {
+    (row: Row<TData>, columnId: string, filterValue: any, addMeta: (meta: any) => void): boolean;
+    resolveFilterValue?: TransformFilterValueFn<TData>;
+    autoRemove?: ColumnFilterAutoRemoveTestFn<TData>;
+};
+declare type TransformFilterValueFn<TData extends RowData> = (value: any, column?: Column<TData>) => unknown;
+declare type ColumnFilterAutoRemoveTestFn<TData extends RowData> = (value: any, column?: Column<TData>) => boolean;
+declare type CustomFilterFns<TData extends RowData> = Record<string, FilterFn<TData>>;
+declare type FilterFnOption<TData extends RowData> = 'auto' | BuiltInFilterFn | FilterFn<TData>;
+declare type FiltersColumnDef<TData extends RowData> = {
+    filterFn?: FilterFnOption<TData>;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
 };
-declare type FiltersColumn<TGenerics extends TableGenerics> = {
-    getAutoFilterFn: () => FilterFn<TGenerics> | undefined;
-    getFilterFn: () => FilterFn<TGenerics> | undefined;
+declare type FiltersColumn<TData extends RowData> = {
+    getAutoFilterFn: () => FilterFn<TData> | undefined;
+    getFilterFn: () => FilterFn<TData> | undefined;
     setFilterValue: (updater: Updater<any>) => void;
     getCanFilter: () => boolean;
     getCanGlobalFilter: () => boolean;
-    getFacetedRowModel: () => RowModel<TGenerics>;
-    _getFacetedRowModel?: () => RowModel<TGenerics>;
+    getFacetedRowModel: () => RowModel<TData>;
+    _getFacetedRowModel?: () => RowModel<TData>;
     getIsFiltered: () => boolean;
     getFilterValue: () => unknown;
     getFilterIndex: () => number;
@@ -247,45 +257,44 @@ declare type FiltersColumn<TGenerics extends TableGenerics> = {
     getFacetedMinMaxValues: () => undefined | [number, number];
     _getFacetedMinMaxValues?: () => undefined | [number, number];
 };
-declare type FiltersRow<TGenerics extends TableGenerics> = {
+declare type FiltersRow<TData extends RowData> = {
     columnFilters: Record<string, boolean>;
-    columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
+    columnFiltersMeta: Record<string, any>;
 };
-declare type FiltersOptions<TGenerics extends TableGenerics> = {
+declare type FiltersOptions<TData extends RowData> = {
     enableFilters?: boolean;
     manualFiltering?: boolean;
     filterFromLeafRows?: boolean;
-    filterFns?: TGenerics['FilterFns'];
-    getFilteredRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    getFilteredRowModel?: (table: Table<any>) => () => RowModel<any>;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
     enableColumnFilters?: boolean;
-    globalFilterFn?: FilterFnOption<TGenerics>;
+    globalFilterFn?: FilterFnOption<TData>;
     onGlobalFilterChange?: OnChangeFn<any>;
     enableGlobalFilter?: boolean;
-    getColumnCanGlobalFilter?: (column: Column<TGenerics>) => boolean;
-    getFacetedRowModel?: (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;
-    getFacetedUniqueValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;
-    getFacetedMinMaxValues?: (instance: TableInstance<TGenerics>, columnId: string) => () => undefined | [number, number];
+    getColumnCanGlobalFilter?: (column: Column<TData>) => boolean;
+    getFacetedRowModel?: (table: Table<TData>, columnId: string) => () => RowModel<TData>;
+    getFacetedUniqueValues?: (table: Table<TData>, columnId: string) => () => Map<any, number>;
+    getFacetedMinMaxValues?: (table: Table<TData>, columnId: string) => () => undefined | [number, number];
 };
-declare type FiltersInstance<TGenerics extends TableGenerics> = {
+declare type FiltersInstance<TData extends RowData> = {
     setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
     resetColumnFilters: (defaultState?: boolean) => void;
-    getPreFilteredRowModel: () => RowModel<TGenerics>;
-    getFilteredRowModel: () => RowModel<TGenerics>;
-    _getFilteredRowModel?: () => RowModel<TGenerics>;
+    getPreFilteredRowModel: () => RowModel<TData>;
+    getFilteredRowModel: () => RowModel<TData>;
+    _getFilteredRowModel?: () => RowModel<TData>;
     setGlobalFilter: (updater: Updater<any>) => void;
     resetGlobalFilter: (defaultState?: boolean) => void;
-    getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
-    getGlobalFilterFn: () => FilterFn<TGenerics> | undefined;
-    getGlobalFacetedRowModel: () => RowModel<TGenerics>;
-    _getGlobalFacetedRowModel?: () => RowModel<TGenerics>;
+    getGlobalAutoFilterFn: () => FilterFn<TData> | undefined;
+    getGlobalFilterFn: () => FilterFn<TData> | undefined;
+    getGlobalFacetedRowModel: () => RowModel<TData>;
+    _getGlobalFacetedRowModel?: () => RowModel<TData>;
     getGlobalFacetedUniqueValues: () => Map<any, number>;
     _getGlobalFacetedUniqueValues?: () => Map<any, number>;
     getGlobalFacetedMinMaxValues: () => undefined | [number, number];
     _getGlobalFacetedMinMaxValues?: () => undefined | [number, number];
 };
 declare const Filters: TableFeature;
-declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;
+declare function shouldAutoRemoveFilter<TData extends RowData>(filterFn?: FilterFn<TData>, value?: any, column?: Column<TData>): boolean;
 
 declare const reSplitAlphaNumeric: RegExp;
 declare const sortingFns: {
@@ -307,25 +316,23 @@ declare type SortingState = ColumnSort[];
 declare type SortingTableState = {
     sorting: SortingState;
 };
-declare type SortingFn<TGenerics extends TableGenerics> = {
-    (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
+declare type SortingFn<TData extends RowData> = {
+    (rowA: Row<TData>, rowB: Row<TData>, columnId: string): number;
 };
-declare type CustomSortingFns<TGenerics extends TableGenerics> = Record<string, SortingFn<TGenerics>>;
-declare type SortingFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInSortingFn | keyof TGenerics['SortingFns'] | SortingFn<TGenerics>;
-declare type SortingColumnDef<TGenerics extends TableGenerics> = {
-    sortingFn?: SortingFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
+declare type CustomSortingFns<TData extends RowData> = Record<string, SortingFn<TData>>;
+declare type SortingFnOption<TData extends RowData> = 'auto' | BuiltInSortingFn | SortingFn<TData>;
+declare type SortingColumnDef<TData extends RowData> = {
+    sortingFn?: SortingFnOption<TData>;
     sortDescFirst?: boolean;
     enableSorting?: boolean;
     enableMultiSort?: boolean;
     invertSorting?: boolean;
     sortUndefined?: false | -1 | 1;
 };
-declare type SortingColumn<TGenerics extends TableGenerics> = {
-    getAutoSortingFn: () => SortingFn<TGenerics>;
+declare type SortingColumn<TData extends RowData> = {
+    getAutoSortingFn: () => SortingFn<TData>;
     getAutoSortDir: () => SortDirection;
-    getSortingFn: () => SortingFn<TGenerics>;
+    getSortingFn: () => SortingFn<TData>;
     getNextSortingOrder: () => SortDirection | false;
     getCanSort: () => boolean;
     getCanMultiSort: () => boolean;
@@ -335,25 +342,24 @@ declare type SortingColumn<TGenerics extends TableGenerics> = {
     toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
     getToggleSortingHandler: () => undefined | ((event: unknown) => void);
 };
-declare type SortingOptions<TGenerics extends TableGenerics> = {
+declare type SortingOptions<TData extends RowData> = {
     manualSorting?: boolean;
-    sortingFns?: TGenerics['SortingFns'];
     onSortingChange?: OnChangeFn<SortingState>;
     enableSorting?: boolean;
     enableSortingRemoval?: boolean;
     enableMultiRemove?: boolean;
     enableMultiSort?: boolean;
     sortDescFirst?: boolean;
-    getSortedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    getSortedRowModel?: (table: Table<any>) => () => RowModel<any>;
     maxMultiSortColCount?: number;
     isMultiSortEvent?: (e: unknown) => boolean;
 };
-declare type SortingInstance<TGenerics extends TableGenerics> = {
+declare type SortingInstance<TData extends RowData> = {
     setSorting: (updater: Updater<SortingState>) => void;
     resetSorting: (defaultState?: boolean) => void;
-    getPreSortedRowModel: () => RowModel<TGenerics>;
-    getSortedRowModel: () => RowModel<TGenerics>;
-    _getSortedRowModel?: () => RowModel<TGenerics>;
+    getPreSortedRowModel: () => RowModel<TData>;
+    getSortedRowModel: () => RowModel<TData>;
+    _getSortedRowModel?: () => RowModel<TData>;
 };
 declare const Sorting: TableFeature;
 
@@ -374,30 +380,22 @@ declare type GroupingState = string[];
 declare type GroupingTableState = {
     grouping: GroupingState;
 };
-declare type AggregationFn<TGenerics extends TableGenerics> = (columnId: string, leafRows: Row<TGenerics>[], childRows: Row<TGenerics>[]) => any;
-declare type CustomAggregationFns<TGenerics extends TableGenerics> = Record<string, AggregationFn<TGenerics>>;
-declare type AggregationFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInAggregationFn | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
-declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
-    aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
-    aggregatedCell?: Renderable<TGenerics, {
-        instance: TableInstance<TGenerics>;
-        row: Row<TGenerics>;
-        column: Column<TGenerics>;
-        cell: Cell<TGenerics>;
-        getValue: () => TGenerics['Value'];
-    }>;
+declare type AggregationFn<TData extends RowData> = (columnId: string, leafRows: Row<TData>[], childRows: Row<TData>[]) => any;
+declare type CustomAggregationFns = Record<string, AggregationFn<any>>;
+declare type AggregationFnOption<TData extends RowData> = 'auto' | BuiltInAggregationFn | AggregationFn<TData>;
+declare type GroupingColumnDef<TData extends RowData> = {
+    aggregationFn?: AggregationFnOption<TData>;
+    aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TData>['getContext']>>;
     enableGrouping?: boolean;
 };
-declare type GroupingColumn<TGenerics extends TableGenerics> = {
+declare type GroupingColumn<TData extends RowData> = {
     getCanGroup: () => boolean;
     getIsGrouped: () => boolean;
     getGroupedIndex: () => number;
     toggleGrouping: () => void;
     getToggleGroupingHandler: () => () => void;
-    getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
-    getAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getAutoAggregationFn: () => AggregationFn<TData> | undefined;
+    getAggregationFn: () => AggregationFn<TData> | undefined;
 };
 declare type GroupingRow = {
     groupingColumnId?: string;
@@ -405,34 +403,32 @@ declare type GroupingRow = {
     getIsGrouped: () => boolean;
     _groupingValuesCache: Record<string, any>;
 };
-declare type GroupingCell<TGenerics extends TableGenerics> = {
+declare type GroupingCell = {
     getIsGrouped: () => boolean;
     getIsPlaceholder: () => boolean;
     getIsAggregated: () => boolean;
-    renderAggregatedCell: () => string | null | TGenerics['Rendered'];
 };
 declare type ColumnDefaultOptions = {
     onGroupingChange: OnChangeFn<GroupingState>;
     enableGrouping: boolean;
 };
-declare type GroupingOptions<TGenerics extends TableGenerics> = {
+declare type GroupingOptions = {
     manualGrouping?: boolean;
-    aggregationFns?: TGenerics['AggregationFns'];
     onGroupingChange?: OnChangeFn<GroupingState>;
     enableGrouping?: boolean;
-    getGroupedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>;
     groupedColumnMode?: false | 'reorder' | 'remove';
 };
 declare type GroupingColumnMode = false | 'reorder' | 'remove';
-declare type GroupingInstance<TGenerics extends TableGenerics> = {
+declare type GroupingInstance<TData extends RowData> = {
     setGrouping: (updater: Updater<GroupingState>) => void;
     resetGrouping: (defaultState?: boolean) => void;
-    getPreGroupedRowModel: () => RowModel<TGenerics>;
-    getGroupedRowModel: () => RowModel<TGenerics>;
-    _getGroupedRowModel?: () => RowModel<TGenerics>;
+    getPreGroupedRowModel: () => RowModel<TData>;
+    getGroupedRowModel: () => RowModel<TData>;
+    _getGroupedRowModel?: () => RowModel<TData>;
 };
 declare const Grouping: TableFeature;
-declare function orderColumns<TGenerics extends TableGenerics>(leafColumns: Column<TGenerics>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TGenerics>[];
+declare function orderColumns<TData extends RowData>(leafColumns: Column<TData>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TData>[];
 
 declare type ExpandedStateList = Record<string, boolean>;
 declare type ExpandedState = true | Record<string, boolean>;
@@ -445,17 +441,17 @@ declare type ExpandedRow = {
     getCanExpand: () => boolean;
     getToggleExpandedHandler: () => () => void;
 };
-declare type ExpandedOptions<TGenerics extends TableGenerics> = {
+declare type ExpandedOptions<TData extends RowData> = {
     manualExpanding?: boolean;
     onExpandedChange?: OnChangeFn<ExpandedState>;
     autoResetExpanded?: boolean;
     enableExpanding?: boolean;
-    getExpandedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
-    getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
-    getRowCanExpand?: (row: Row<TGenerics>) => boolean;
+    getExpandedRowModel?: (table: Table<any>) => () => RowModel<any>;
+    getIsRowExpanded?: (row: Row<TData>) => boolean;
+    getRowCanExpand?: (row: Row<TData>) => boolean;
     paginateExpandedRows?: boolean;
 };
-declare type ExpandedInstance<TGenerics extends TableGenerics> = {
+declare type ExpandedInstance<TData extends RowData> = {
     _autoResetExpanded: () => void;
     setExpanded: (updater: Updater<ExpandedState>) => void;
     toggleAllRowsExpanded: (expanded?: boolean) => void;
@@ -465,9 +461,9 @@ declare type ExpandedInstance<TGenerics extends TableGenerics> = {
     getIsSomeRowsExpanded: () => boolean;
     getIsAllRowsExpanded: () => boolean;
     getExpandedDepth: () => number;
-    getExpandedRowModel: () => RowModel<TGenerics>;
-    _getExpandedRowModel?: () => RowModel<TGenerics>;
-    getPreExpandedRowModel: () => RowModel<TGenerics>;
+    getExpandedRowModel: () => RowModel<TData>;
+    _getExpandedRowModel?: () => RowModel<TData>;
+    getPreExpandedRowModel: () => RowModel<TData>;
 };
 declare const Expanding: TableFeature;
 
@@ -496,7 +492,7 @@ declare type ColumnSizingDefaultOptions = {
     onColumnSizingChange: OnChangeFn<ColumnSizingState>;
     onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
 };
-declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
+declare type ColumnSizingInstance = {
     setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
     setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
     resetColumnSizing: (defaultState?: boolean) => void;
@@ -512,14 +508,14 @@ declare type ColumnSizingColumnDef = {
     minSize?: number;
     maxSize?: number;
 };
-declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
+declare type ColumnSizingColumn = {
     getSize: () => number;
     getStart: (position?: ColumnPinningPosition) => number;
     getCanResize: () => boolean;
     getIsResizing: () => boolean;
     resetSize: () => void;
 };
-declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
+declare type ColumnSizingHeader = {
     getSize: () => number;
     getStart: (position?: ColumnPinningPosition) => number;
     getResizeHandler: () => (event: unknown) => void;
@@ -542,17 +538,17 @@ declare type PaginationTableState = {
 declare type PaginationInitialTableState = {
     pagination?: Partial<PaginationState>;
 };
-declare type PaginationOptions<TGenerics extends TableGenerics> = {
+declare type PaginationOptions = {
     pageCount?: number;
     manualPagination?: boolean;
     onPaginationChange?: OnChangeFn<PaginationState>;
     autoResetPageIndex?: boolean;
-    getPaginationRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>;
 };
 declare type PaginationDefaultOptions = {
     onPaginationChange: OnChangeFn<PaginationState>;
 };
-declare type PaginationInstance<TGenerics extends TableGenerics> = {
+declare type PaginationInstance<TData extends RowData> = {
     _autoResetPageIndex: () => void;
     setPagination: (updater: Updater<PaginationState>) => void;
     resetPagination: (defaultState?: boolean) => void;
@@ -566,9 +562,9 @@ declare type PaginationInstance<TGenerics extends TableGenerics> = {
     getCanNextPage: () => boolean;
     previousPage: () => void;
     nextPage: () => void;
-    getPrePaginationRowModel: () => RowModel<TGenerics>;
-    getPaginationRowModel: () => RowModel<TGenerics>;
-    _getPaginationRowModel?: () => RowModel<TGenerics>;
+    getPrePaginationRowModel: () => RowModel<TData>;
+    getPaginationRowModel: () => RowModel<TData>;
+    _getPaginationRowModel?: () => RowModel<TData>;
     getPageCount: () => number;
 };
 declare const Pagination: TableFeature;
@@ -577,10 +573,10 @@ declare type RowSelectionState = Record<string, boolean>;
 declare type RowSelectionTableState = {
     rowSelection: RowSelectionState;
 };
-declare type RowSelectionOptions<TGenerics extends TableGenerics> = {
-    enableRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
-    enableMultiRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
-    enableSubRowSelection?: boolean | ((row: Row<TGenerics>) => boolean);
+declare type RowSelectionOptions<TData extends RowData> = {
+    enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
+    enableMultiRowSelection?: boolean | ((row: Row<TData>) => boolean);
+    enableSubRowSelection?: boolean | ((row: Row<TData>) => boolean);
     onRowSelectionChange?: OnChangeFn<RowSelectionState>;
 };
 declare type RowSelectionRow = {
@@ -592,7 +588,7 @@ declare type RowSelectionRow = {
     toggleSelected: (value?: boolean) => void;
     getToggleSelectedHandler: () => (event: unknown) => void;
 };
-declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
+declare type RowSelectionInstance<TData extends RowData> = {
     getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
     getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
     setRowSelection: (updater: Updater<RowSelectionState>) => void;
@@ -603,74 +599,62 @@ declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
     getIsSomePageRowsSelected: () => boolean;
     toggleAllRowsSelected: (value?: boolean) => void;
     toggleAllPageRowsSelected: (value?: boolean) => void;
-    getPreSelectedRowModel: () => RowModel<TGenerics>;
-    getSelectedRowModel: () => RowModel<TGenerics>;
-    getFilteredSelectedRowModel: () => RowModel<TGenerics>;
-    getGroupedSelectedRowModel: () => RowModel<TGenerics>;
+    getPreSelectedRowModel: () => RowModel<TData>;
+    getSelectedRowModel: () => RowModel<TData>;
+    getFilteredSelectedRowModel: () => RowModel<TData>;
+    getGroupedSelectedRowModel: () => RowModel<TData>;
 };
 declare const RowSelection: TableFeature;
-declare function selectRowsFn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
-declare function isRowSelected<TGenerics extends TableGenerics>(row: Row<TGenerics>, selection: Record<string, boolean>, instance: TableInstance<TGenerics>): boolean | 'some';
+declare function selectRowsFn<TData extends RowData>(table: Table<TData>, rowModel: RowModel<TData>): RowModel<TData>;
+declare function isRowSelected<TData extends RowData>(row: Row<TData>, selection: Record<string, boolean>, table: Table<TData>): boolean | 'some';
 
-declare type CoreRow<TGenerics extends TableGenerics> = {
+declare type CoreRow<TData extends RowData> = {
     id: string;
     index: number;
-    original?: TGenerics['Row'];
+    original?: TData;
     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>>;
-};
-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>;
-
-declare type CoreCell<TGenerics extends TableGenerics> = {
-    id: string;
-    getValue: () => TGenerics['Value'];
-    row: Row<TGenerics>;
-    column: Column<TGenerics>;
-    renderCell: () => string | null | TGenerics['Rendered'];
-};
+    renderValue: (columnId: string) => unknown;
+    subRows: Row<TData>[];
+    getLeafRows: () => Row<TData>[];
+    originalSubRows?: TData[];
+    getAllCells: () => Cell<TData>[];
+    _getAllCellsByColumnId: () => Record<string, Cell<TData>>;
+};
+declare const createRow: <TData extends RowData>(table: Table<TData>, id: string, original: TData | undefined, rowIndex: number, depth: number, subRows?: Row<TData>[] | undefined) => Row<TData>;
 
 declare type Updater<T> = T | ((old: T) => T);
 declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+declare type RowData = object | any[];
 declare type TableGenerics = {
     Row?: any;
     Value?: any;
-    FilterFns?: any;
-    SortingFns?: any;
-    AggregationFns?: any;
-    Renderer?: any;
-    Rendered?: any;
     ColumnMeta?: any;
     TableMeta?: any;
-    FilterMeta?: any;
 };
 declare type AnyRender = (Comp: any, props: any) => any;
-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>;
-declare type TableOptionsResolved<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
-declare type TableOptions<TGenerics extends TableGenerics> = Omit<PartialKeys<TableOptionsResolved<TGenerics>, 'state' | 'onStateChange'>, 'render' | 'renderFallbackValue'>;
+declare type Table<TData extends RowData> = CoreInstance<TData> & HeadersInstance<TData> & VisibilityInstance<TData> & ColumnOrderInstance<TData> & ColumnPinningInstance<TData> & FiltersInstance<TData> & SortingInstance<TData> & GroupingInstance<TData> & ColumnSizingInstance & ExpandedInstance<TData> & PaginationInstance<TData> & RowSelectionInstance<TData>;
+declare type TableOptionsResolved<TData extends RowData> = CoreOptions<TData> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TData> & SortingOptions<TData> & GroupingOptions & ExpandedOptions<TData> & ColumnSizingOptions & PaginationOptions & RowSelectionOptions<TData>;
+declare type TableOptions<TData extends RowData> = PartialKeys<TableOptionsResolved<TData>, 'state' | 'onStateChange' | 'renderFallbackValue'>;
 declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
 declare type InitialTableState = Partial<CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationInitialTableState & RowSelectionTableState>;
-declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & FiltersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
+declare type Row<TData extends RowData> = CoreRow<TData> & VisibilityRow<TData> & ColumnPinningRow<TData> & FiltersRow<TData> & GroupingRow & RowSelectionRow & ExpandedRow;
 declare type RowValues = {
     [key: string]: any;
 };
-declare type RowModel<TGenerics extends TableGenerics> = {
-    rows: Row<TGenerics>[];
-    flatRows: Row<TGenerics>[];
-    rowsById: Record<string, Row<TGenerics>>;
-};
-declare type AccessorFn<TData> = (originalRow: TData, index: number) => any;
-declare type Renderable<TGenerics extends TableGenerics, TProps> = string | ((props: TProps) => TGenerics['Rendered']);
-declare type ColumnDef<TGenerics extends TableGenerics> = CoreColumnDef<TGenerics> & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TGenerics> & SortingColumnDef<TGenerics> & GroupingColumnDef<TGenerics> & ColumnSizingColumnDef;
-declare type Column<TGenerics extends TableGenerics> = CoreColumn<TGenerics> & VisibilityColumn & ColumnPinningColumn & FiltersColumn<TGenerics> & SortingColumn<TGenerics> & GroupingColumn<TGenerics> & ColumnSizingColumn<TGenerics>;
-declare type Cell<TGenerics extends TableGenerics> = CoreCell<TGenerics> & GroupingCell<TGenerics>;
-declare type Header<TGenerics extends TableGenerics> = CoreHeader<TGenerics> & ColumnSizingHeader<TGenerics>;
-declare type HeaderGroup<TGenerics extends TableGenerics> = CoreHeaderGroup<TGenerics>;
+declare type RowModel<TData extends RowData> = {
+    rows: Row<TData>[];
+    flatRows: Row<TData>[];
+    rowsById: Record<string, Row<TData>>;
+};
+declare type AccessorFn<TData extends RowData> = (originalRow: TData, index: number) => any;
+declare type ColumnDefTemplate<TProps extends object> = string | ((props: TProps) => unknown);
+declare type ColumnDef<TData extends RowData> = CoreColumnDef<TData> & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TData> & SortingColumnDef<TData> & GroupingColumnDef<TData> & ColumnSizingColumnDef;
+declare type Column<TData extends RowData> = CoreColumn<TData> & VisibilityColumn & ColumnPinningColumn & FiltersColumn<TData> & SortingColumn<TData> & GroupingColumn<TData> & ColumnSizingColumn;
+declare type Cell<TData extends RowData> = CoreCell<TData> & GroupingCell;
+declare type Header<TData extends RowData> = CoreHeader<TData> & ColumnSizingHeader;
+declare type HeaderGroup<TData extends RowData> = CoreHeaderGroup<TData>;
 declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];
 
 declare type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
@@ -678,10 +662,11 @@ declare type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T,
 declare type Overwrite<T, U extends {
     [TKey in keyof T]?: any;
 }> = Omit<T, keyof U> & U;
+declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
 declare type IfDefined<T, N> = 0 extends 1 & T ? N : T extends {} ? T : N;
 declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
 declare function noop(): void;
-declare function makeStateUpdater(key: keyof TableState, instance: unknown): (updater: Updater<any>) => void;
+declare function makeStateUpdater(key: keyof TableState, table: unknown): (updater: Updater<any>) => void;
 declare type AnyFunction = (...args: any) => any;
 declare function isFunction<T extends AnyFunction>(d: any): d is T;
 declare function flattenBy<TNode>(arr: TNode[], getChildren: (item: TNode) => TNode[]): TNode[];
@@ -692,21 +677,20 @@ declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...
 }): () => TResult;
 
 declare type TableFeature = {
-    getDefaultOptions?: (instance: any) => any;
+    getDefaultOptions?: (table: any) => any;
     getInitialState?: (initialState?: InitialTableState) => any;
-    createInstance?: (instance: any) => any;
+    createTable?: (table: 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;
+    createColumn?: (column: any, table: any) => any;
+    createHeader?: (column: any, table: any) => any;
+    createCell?: (cell: any, column: any, row: any, table: any) => any;
+    createRow?: (row: any, table: any) => any;
 };
 declare type CoreTableState = {};
-declare type CoreOptions<TGenerics extends TableGenerics> = {
-    data: TGenerics['Row'][];
+declare type CoreOptions<TData extends RowData> = {
+    data: TData[];
     state: Partial<TableState>;
     onStateChange: (updater: Updater<TableState>) => void;
-    render: TGenerics['Renderer'];
     debugAll?: boolean;
     debugTable?: boolean;
     debugHeaders?: boolean;
@@ -714,122 +698,62 @@ declare type CoreOptions<TGenerics extends TableGenerics> = {
     debugRows?: boolean;
     initialState?: InitialTableState;
     autoResetAll?: boolean;
-    mergeOptions?: (defaultOptions: TableOptions<TGenerics>, options: Partial<TableOptions<TGenerics>>) => TableOptions<TGenerics>;
-    meta?: TGenerics['TableMeta'];
-    getCoreRowModel: (instance: TableInstance<any>) => () => RowModel<any>;
-    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>>;
+    mergeOptions?: (defaultOptions: TableOptions<TData>, options: Partial<TableOptions<TData>>) => TableOptions<TData>;
+    meta?: unknown;
+    getCoreRowModel: (table: Table<any>) => () => RowModel<any>;
+    getSubRows?: (originalRow: TData, index: number) => undefined | TData[];
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
+    columns: ColumnDef<TData>[];
+    defaultColumn?: Partial<ColumnDef<TData>>;
     renderFallbackValue: any;
 };
-declare type CoreInstance<TGenerics extends TableGenerics> = {
+declare type CoreInstance<TData extends RowData> = {
     initialState: TableState;
     reset: () => void;
-    options: RequiredKeys<TableOptionsResolved<TGenerics>, 'state'>;
-    setOptions: (newOptions: Updater<TableOptionsResolved<TGenerics>>) => void;
+    options: RequiredKeys<TableOptionsResolved<TData>, 'state'>;
+    setOptions: (newOptions: Updater<TableOptionsResolved<TData>>) => 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>;
-};
-declare function createTableInstance<TGenerics extends TableGenerics>(options: TableOptionsResolved<TGenerics>): TableInstance<TGenerics>;
-
-declare type TableFactory<TGenerics extends TableGenerics> = () => Table<TGenerics>;
-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<TableOptionsResolved<TGenerics>, 'filterFns' | 'sortingFns' | 'aggregationFns'>>;
-declare type Table<TGenerics extends TableGenerics> = {
-    generics: TGenerics;
-    options: Partial<TableOptionsResolved<TGenerics>>;
-    setRowType: <TRow>() => Table<Overwrite<TGenerics, {
-        Row: TRow;
-    }>>;
-    setTableMetaType: <TTableMeta>() => Table<Overwrite<TGenerics, {
-        TableMeta: TTableMeta;
-    }>>;
-    setColumnMetaType: <TColumnMeta>() => Table<Overwrite<TGenerics, {
-        ColumnMeta: TColumnMeta;
-    }>>;
-    setFilterMetaType: <TFilterMeta>() => Table<Overwrite<TGenerics, {
-        FilterMeta: TFilterMeta;
-    }>>;
-    setOptions: <TFilterFns extends Record<string, FilterFn<any>>, TSortingFns extends Record<string, SortingFn<any>>, TAggregationFns extends Record<string, AggregationFn<any>>>(options: CreateTableOptions<any, TFilterFns, TSortingFns, TAggregationFns, TGenerics>) => Table<Overwrite<TGenerics, {
-        FilterFns: IfDefined<TFilterFns, TGenerics['FilterFns']>;
-        SortingFns: IfDefined<TSortingFns, TGenerics['SortingFns']>;
-        AggregationFns: IfDefined<TAggregationFns, TGenerics['AggregationFns']>;
-    }>>;
-    createGroup: (column: Overwrite<Overwrite<ColumnDef<any>, {
-        header: string;
-        id?: string;
-    }> | Overwrite<ColumnDef<any>, {
-        id: string;
-        header?: string | ((...any: any) => any);
-    }>, {
-        accessorFn?: never;
-        accessorKey?: never;
-        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, {
-        Value: TGenerics['Row'][TAccessor];
-    }>>, {
-        id?: string;
-    }> : never, {
-        accessorFn?: never;
-        accessorKey?: never;
-        columns?: ColumnDef<any>[];
-    }>) => ColumnDef<TGenerics>;
-    createOptions: (options: TableOptions<TGenerics>) => TableOptions<TGenerics>;
-};
-declare function createTableFactory<TRenderer extends AnyRender>(opts: {
-    render: TRenderer;
-}): () => Table<{
-    Renderer: TRenderer;
-    Rendered: ReturnType<TRenderer>;
-}>;
+    _getRowId: (_: TData, index: number, parent?: Row<TData>) => string;
+    getCoreRowModel: () => RowModel<TData>;
+    _getCoreRowModel?: () => RowModel<TData>;
+    getRowModel: () => RowModel<TData>;
+    getRow: (id: string) => Row<TData>;
+    _getDefaultColumnDef: () => Partial<ColumnDef<TData>>;
+    _getColumnDefs: () => ColumnDef<TData>[];
+    _getAllFlatColumnsById: () => Record<string, Column<TData>>;
+    getAllColumns: () => Column<TData>[];
+    getAllFlatColumns: () => Column<TData>[];
+    getAllLeafColumns: () => Column<TData>[];
+    getColumn: (columnId: string) => Column<TData>;
+};
+declare function createTable<TData extends RowData>(options: TableOptionsResolved<TData>): Table<TData>;
 
-declare function getCoreRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+declare function getCoreRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
 
-declare function getFilteredRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+declare function getFilteredRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
 
-declare function getFacetedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;
+declare function getFacetedRowModel<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => RowModel<TData>;
 
-declare function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;
+declare function getFacetedUniqueValues<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => Map<any, number>;
 
-declare function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => undefined | [number, number];
+declare function getFacetedMinMaxValues<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => undefined | [number, number];
 
-declare function getSortedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+declare function getSortedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
 
-declare function getGroupedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+declare function getGroupedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
 
-declare function getExpandedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
-declare function expandRows<TGenerics extends TableGenerics>(rowModel: RowModel<TGenerics>, instance: TableInstance<TGenerics>): {
-    rows: Row<TGenerics>[];
-    flatRows: Row<TGenerics>[];
-    rowsById: Record<string, Row<TGenerics>>;
+declare function getExpandedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+declare function expandRows<TData extends RowData>(rowModel: RowModel<TData>, table: Table<TData>): {
+    rows: Row<TData>[];
+    flatRows: Row<TData>[];
+    rowsById: Record<string, Row<TData>>;
 };
 
-declare function getPaginationRowModel<TGenerics extends TableGenerics>(opts?: {
+declare function getPaginationRowModel<TData extends RowData>(opts?: {
     initialSync: boolean;
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+}): (table: Table<TData>) => () => RowModel<TData>;
 
-export { AccessorFn, AggregationFn, AggregationFnOption, AnyRender, BuiltInAggregationFn, BuiltInFilterFn, BuiltInSortingFn, Cell, Column, ColumnDef, ColumnDefaultOptions, ColumnFilter, ColumnFilterAutoRemoveTestFn, ColumnFiltersState, ColumnOrderDefaultOptions, ColumnOrderInstance, ColumnOrderOptions, ColumnOrderState, ColumnOrderTableState, ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningDefaultOptions, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningPosition, ColumnPinningRow, ColumnPinningState, ColumnPinningTableState, ColumnResizeMode, ColumnSizing, ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingDefaultOptions, ColumnSizingHeader, ColumnSizingInfoState, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingState, ColumnSizingTableState, ColumnSort, CoreColumn, CoreColumnDef, CoreColumnDefType, CoreHeader, CoreHeaderGroup, CoreInstance, CoreOptions, CoreRow, CoreTableState, CreateTableOptions, CustomAggregationFns, CustomFilterFns, CustomSortingFns, ExpandedInstance, ExpandedOptions, ExpandedRow, ExpandedState, ExpandedStateList, ExpandedTableState, Expanding, FilterFn, FilterFnOption, Filters, FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersRow, FiltersTableState, Grouping, GroupingCell, GroupingColumn, GroupingColumnDef, GroupingColumnMode, GroupingInstance, GroupingOptions, GroupingRow, GroupingState, GroupingTableState, Header, HeaderGroup, Headers, HeadersInstance, IfDefined, InitialTableState, NoInfer, OnChangeFn, Ordering, Overwrite, Pagination, PaginationDefaultOptions, PaginationInitialTableState, PaginationInstance, PaginationOptions, PaginationState, PaginationTableState, PartialKeys, Pinning, Renderable, RequiredKeys, ResolvedColumnFilter, Row, RowModel, RowSelection, RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionState, RowSelectionTableState, RowValues, SortDirection, Sorting, SortingColumn, SortingColumnDef, SortingFn, SortingFnOption, SortingInstance, SortingOptions, SortingState, SortingTableState, Table, TableFactory, TableFeature, TableGenerics, TableInstance, TableOptions, TableOptionsResolved, TableState, TransformFilterValueFn, Updater, Visibility, VisibilityColumn, VisibilityColumnDef, VisibilityDefaultOptions, VisibilityInstance, VisibilityOptions, VisibilityRow, VisibilityState, VisibilityTableState, aggregationFns, buildHeaderGroups, createColumn, createRow, createTableFactory, createTableInstance, defaultColumnSizing, expandRows, filterFns, flattenBy, functionalUpdate, getCoreRowModel, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getPaginationRowModel, getSortedRowModel, isFunction, isRowSelected, makeStateUpdater, memo, noop, orderColumns, passiveEventSupported, reSplitAlphaNumeric, selectRowsFn, shouldAutoRemoveFilter, sortingFns };
+export { AccessorFn, AggregationFn, AggregationFnOption, AnyRender, BuiltInAggregationFn, BuiltInFilterFn, BuiltInSortingFn, Cell, Column, ColumnDef, ColumnDefTemplate, ColumnDefaultOptions, ColumnFilter, ColumnFilterAutoRemoveTestFn, ColumnFiltersState, ColumnOrderDefaultOptions, ColumnOrderInstance, ColumnOrderOptions, ColumnOrderState, ColumnOrderTableState, ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningDefaultOptions, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningPosition, ColumnPinningRow, ColumnPinningState, ColumnPinningTableState, ColumnResizeMode, ColumnSizing, ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingDefaultOptions, ColumnSizingHeader, ColumnSizingInfoState, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingState, ColumnSizingTableState, ColumnSort, CoreColumn, CoreColumnDef, CoreColumnDefResolved, CoreColumnDefType, CoreHeader, CoreHeaderGroup, CoreInstance, CoreOptions, CoreRow, CoreTableState, CustomAggregationFns, CustomFilterFns, CustomSortingFns, ExpandedInstance, ExpandedOptions, ExpandedRow, ExpandedState, ExpandedStateList, ExpandedTableState, Expanding, FilterFn, FilterFnOption, Filters, FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersRow, FiltersTableState, Grouping, GroupingCell, GroupingColumn, GroupingColumnDef, GroupingColumnMode, GroupingInstance, GroupingOptions, GroupingRow, GroupingState, GroupingTableState, Header, HeaderGroup, Headers, HeadersInstance, IfDefined, InitialTableState, NoInfer, OnChangeFn, Ordering, Overwrite, Pagination, PaginationDefaultOptions, PaginationInitialTableState, PaginationInstance, PaginationOptions, PaginationState, PaginationTableState, PartialKeys, Pinning, RequiredKeys, ResolvedColumnFilter, Row, RowData, RowModel, RowSelection, RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionState, RowSelectionTableState, RowValues, SortDirection, Sorting, SortingColumn, SortingColumnDef, SortingFn, SortingFnOption, SortingInstance, SortingOptions, SortingState, SortingTableState, Table, TableFeature, TableGenerics, TableOptions, TableOptionsResolved, TableState, TransformFilterValueFn, UnionToIntersection, Updater, Visibility, VisibilityColumn, VisibilityColumnDef, VisibilityDefaultOptions, VisibilityInstance, VisibilityOptions, VisibilityRow, VisibilityState, VisibilityTableState, aggregationFns, buildHeaderGroups, createColumn, createRow, createTable, defaultColumnSizing, expandRows, filterFns, flattenBy, functionalUpdate, getCoreRowModel, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getPaginationRowModel, getSortedRowModel, isFunction, isRowSelected, makeStateUpdater, memo, noop, orderColumns, passiveEventSupported, reSplitAlphaNumeric, selectRowsFn, shouldAutoRemoveFilter, sortingFns };