@tanstack/table-core 8.0.12 → 8.0.13

package/build/types/index.d.ts

@@ -1,29 +1,835 @@
-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/Expanding';
-export * from './features/Filters';
-export * from './features/Grouping';
-export * from './features/Ordering';
-export * from './features/Pagination';
-export * from './features/Pinning';
-export * from './features/RowSelection';
-export * from './features/Sorting';
-export * from './features/Visibility';
-export * from './filterFns';
-export * from './sortingFns';
-export * from './aggregationFns';
-export * from './utils';
-export * from './utils/getCoreRowModel';
-export * from './utils/getFilteredRowModel';
-export * from './utils/getFacetedRowModel';
-export * from './utils/getFacetedUniqueValues';
-export * from './utils/getFacetedMinMaxValues';
-export * from './utils/getSortedRowModel';
-export * from './utils/getGroupedRowModel';
-export * from './utils/getExpandedRowModel';
-export * from './utils/getPaginationRowModel';
+/**
+ * table-core
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+declare type CoreColumnDefType = 'data' | 'display' | 'group';
+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>;
+        getValue: () => TGenerics['Value'];
+    }>;
+    meta?: TGenerics['ColumnMeta'];
+};
+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>[];
+};
+declare function createColumn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, columnDef: ColumnDef<TGenerics> & {
+    columnDefType?: CoreColumnDefType;
+}, depth: number, parent?: Column<TGenerics>): Column<TGenerics>;
+
+declare type VisibilityState = Record<string, boolean>;
+declare type VisibilityTableState = {
+    columnVisibility: VisibilityState;
+};
+declare type VisibilityOptions = {
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    enableHiding?: boolean;
+};
+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>[];
+    setColumnVisibility: (updater: Updater<VisibilityState>) => void;
+    resetColumnVisibility: (defaultState?: boolean) => void;
+    toggleAllColumnsVisible: (value?: boolean) => void;
+    getIsAllColumnsVisible: () => boolean;
+    getIsSomeColumnsVisible: () => boolean;
+    getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+};
+declare type VisibilityColumnDef = {
+    enableHiding?: boolean;
+};
+declare type VisibilityRow<TGenerics extends TableGenerics> = {
+    _getAllVisibleCells: () => Cell<TGenerics>[];
+    getVisibleCells: () => Cell<TGenerics>[];
+};
+declare type VisibilityColumn = {
+    getCanHide: () => boolean;
+    getIsVisible: () => boolean;
+    toggleVisibility: (value?: boolean) => void;
+    getToggleVisibilityHandler: () => (event: unknown) => void;
+};
+declare const Visibility: TableFeature;
+
+declare type ColumnOrderTableState = {
+    columnOrder: ColumnOrderState;
+};
+declare type ColumnOrderState = string[];
+declare type ColumnOrderOptions = {
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+};
+declare type ColumnOrderDefaultOptions = {
+    onColumnOrderChange: OnChangeFn<ColumnOrderState>;
+};
+declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
+    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
+    resetColumnOrder: (defaultState?: boolean) => void;
+    _getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
+};
+declare const Ordering: TableFeature;
+
+declare type ColumnPinningPosition = false | 'left' | 'right';
+declare type ColumnPinningState = {
+    left?: string[];
+    right?: string[];
+};
+declare type ColumnPinningTableState = {
+    columnPinning: ColumnPinningState;
+};
+declare type ColumnPinningOptions = {
+    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
+    enablePinning?: boolean;
+};
+declare type ColumnPinningDefaultOptions = {
+    onColumnPinningChange: OnChangeFn<ColumnPinningState>;
+};
+declare type ColumnPinningColumnDef = {
+    enablePinning?: boolean;
+};
+declare type ColumnPinningColumn = {
+    getCanPin: () => boolean;
+    getPinnedIndex: () => number;
+    getIsPinned: () => ColumnPinningPosition;
+    pin: (position: ColumnPinningPosition) => void;
+};
+declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
+    getLeftVisibleCells: () => Cell<TGenerics>[];
+    getCenterVisibleCells: () => Cell<TGenerics>[];
+    getRightVisibleCells: () => Cell<TGenerics>[];
+};
+declare type ColumnPinningInstance<TGenerics extends TableGenerics> = {
+    setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
+    resetColumnPinning: (defaultState?: boolean) => void;
+    getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
+    getLeftLeafColumns: () => Column<TGenerics>[];
+    getRightLeafColumns: () => Column<TGenerics>[];
+    getCenterLeafColumns: () => Column<TGenerics>[];
+};
+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>;
+    equalsString: FilterFn<any>;
+    arrIncludes: FilterFn<any>;
+    arrIncludesAll: FilterFn<any>;
+    arrIncludesSome: FilterFn<any>;
+    equals: FilterFn<any>;
+    weakEquals: FilterFn<any>;
+    inNumberRange: FilterFn<any>;
+};
+declare type BuiltInFilterFn = keyof typeof filterFns;
+
+declare type FiltersTableState = {
+    columnFilters: ColumnFiltersState;
+    globalFilter: any;
+};
+declare type ColumnFiltersState = ColumnFilter[];
+declare type ColumnFilter = {
+    id: string;
+    value: unknown;
+};
+declare type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
+    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;
+    }>>;
+    enableColumnFilter?: boolean;
+    enableGlobalFilter?: boolean;
+};
+declare type FiltersColumn<TGenerics extends TableGenerics> = {
+    getAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getFilterFn: () => FilterFn<TGenerics> | undefined;
+    setFilterValue: (updater: Updater<any>) => void;
+    getCanFilter: () => boolean;
+    getCanGlobalFilter: () => boolean;
+    getFacetedRowModel: () => RowModel<TGenerics>;
+    _getFacetedRowModel?: () => RowModel<TGenerics>;
+    getIsFiltered: () => boolean;
+    getFilterValue: () => unknown;
+    getFilterIndex: () => number;
+    getFacetedUniqueValues: () => Map<any, number>;
+    _getFacetedUniqueValues?: () => Map<any, number>;
+    getFacetedMinMaxValues: () => undefined | [number, number];
+    _getFacetedMinMaxValues?: () => undefined | [number, number];
+};
+declare type FiltersRow<TGenerics extends TableGenerics> = {
+    columnFilters: Record<string, boolean>;
+    columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
+};
+declare type FiltersOptions<TGenerics extends TableGenerics> = {
+    enableFilters?: boolean;
+    manualFiltering?: boolean;
+    filterFromLeafRows?: boolean;
+    filterFns?: TGenerics['FilterFns'];
+    getFilteredRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    enableColumnFilters?: boolean;
+    globalFilterFn?: FilterFnOption<TGenerics>;
+    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];
+};
+declare type FiltersInstance<TGenerics extends TableGenerics> = {
+    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
+    resetColumnFilters: (defaultState?: boolean) => void;
+    getPreFilteredRowModel: () => RowModel<TGenerics>;
+    getFilteredRowModel: () => RowModel<TGenerics>;
+    _getFilteredRowModel?: () => RowModel<TGenerics>;
+    setGlobalFilter: (updater: Updater<any>) => void;
+    resetGlobalFilter: (defaultState?: boolean) => void;
+    getGlobalAutoFilterFn: () => FilterFn<TGenerics> | undefined;
+    getGlobalFilterFn: () => FilterFn<TGenerics> | undefined;
+    getGlobalFacetedRowModel: () => RowModel<TGenerics>;
+    _getGlobalFacetedRowModel?: () => RowModel<TGenerics>;
+    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 const reSplitAlphaNumeric: RegExp;
+declare const sortingFns: {
+    alphanumeric: SortingFn<any>;
+    alphanumericCaseSensitive: SortingFn<any>;
+    text: SortingFn<any>;
+    textCaseSensitive: SortingFn<any>;
+    datetime: SortingFn<any>;
+    basic: SortingFn<any>;
+};
+declare type BuiltInSortingFn = keyof typeof sortingFns;
+
+declare type SortDirection = 'asc' | 'desc';
+declare type ColumnSort = {
+    id: string;
+    desc: boolean;
+};
+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 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;
+    }>>;
+    sortDescFirst?: boolean;
+    enableSorting?: boolean;
+    enableMultiSort?: boolean;
+    invertSorting?: boolean;
+    sortUndefined?: false | -1 | 1;
+};
+declare type SortingColumn<TGenerics extends TableGenerics> = {
+    getAutoSortingFn: () => SortingFn<TGenerics>;
+    getAutoSortDir: () => SortDirection;
+    getSortingFn: () => SortingFn<TGenerics>;
+    getNextSortingOrder: () => SortDirection | false;
+    getCanSort: () => boolean;
+    getCanMultiSort: () => boolean;
+    getSortIndex: () => number;
+    getIsSorted: () => false | SortDirection;
+    clearSorting: () => void;
+    toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+    getToggleSortingHandler: () => undefined | ((event: unknown) => void);
+};
+declare type SortingOptions<TGenerics extends TableGenerics> = {
+    manualSorting?: boolean;
+    sortingFns?: TGenerics['SortingFns'];
+    onSortingChange?: OnChangeFn<SortingState>;
+    enableSorting?: boolean;
+    enableSortingRemoval?: boolean;
+    enableMultiRemove?: boolean;
+    enableMultiSort?: boolean;
+    sortDescFirst?: boolean;
+    getSortedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    maxMultiSortColCount?: number;
+    isMultiSortEvent?: (e: unknown) => boolean;
+};
+declare type SortingInstance<TGenerics extends TableGenerics> = {
+    setSorting: (updater: Updater<SortingState>) => void;
+    resetSorting: (defaultState?: boolean) => void;
+    getPreSortedRowModel: () => RowModel<TGenerics>;
+    getSortedRowModel: () => RowModel<TGenerics>;
+    _getSortedRowModel?: () => RowModel<TGenerics>;
+};
+declare const Sorting: TableFeature;
+
+declare const aggregationFns: {
+    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>;
+};
+declare type BuiltInAggregationFn = keyof typeof aggregationFns;
+
+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'];
+    }>;
+    enableGrouping?: boolean;
+};
+declare type GroupingColumn<TGenerics extends TableGenerics> = {
+    getCanGroup: () => boolean;
+    getIsGrouped: () => boolean;
+    getGroupedIndex: () => number;
+    toggleGrouping: () => void;
+    getToggleGroupingHandler: () => () => void;
+    getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
+    getAggregationFn: () => AggregationFn<TGenerics> | undefined;
+};
+declare type GroupingRow = {
+    groupingColumnId?: string;
+    groupingValue?: any;
+    getIsGrouped: () => boolean;
+    _groupingValuesCache: Record<string, any>;
+};
+declare type GroupingCell<TGenerics extends TableGenerics> = {
+    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> = {
+    manualGrouping?: boolean;
+    aggregationFns?: TGenerics['AggregationFns'];
+    onGroupingChange?: OnChangeFn<GroupingState>;
+    enableGrouping?: boolean;
+    getGroupedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+    groupedColumnMode?: false | 'reorder' | 'remove';
+};
+declare type GroupingColumnMode = false | 'reorder' | 'remove';
+declare type GroupingInstance<TGenerics extends TableGenerics> = {
+    setGrouping: (updater: Updater<GroupingState>) => void;
+    resetGrouping: (defaultState?: boolean) => void;
+    getPreGroupedRowModel: () => RowModel<TGenerics>;
+    getGroupedRowModel: () => RowModel<TGenerics>;
+    _getGroupedRowModel?: () => RowModel<TGenerics>;
+};
+declare const Grouping: TableFeature;
+declare function orderColumns<TGenerics extends TableGenerics>(leafColumns: Column<TGenerics>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TGenerics>[];
+
+declare type ExpandedStateList = Record<string, boolean>;
+declare type ExpandedState = true | Record<string, boolean>;
+declare type ExpandedTableState = {
+    expanded: ExpandedState;
+};
+declare type ExpandedRow = {
+    toggleExpanded: (expanded?: boolean) => void;
+    getIsExpanded: () => boolean;
+    getCanExpand: () => boolean;
+    getToggleExpandedHandler: () => () => void;
+};
+declare type ExpandedOptions<TGenerics extends TableGenerics> = {
+    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;
+    paginateExpandedRows?: boolean;
+};
+declare type ExpandedInstance<TGenerics extends TableGenerics> = {
+    _autoResetExpanded: () => void;
+    setExpanded: (updater: Updater<ExpandedState>) => void;
+    toggleAllRowsExpanded: (expanded?: boolean) => void;
+    resetExpanded: (defaultState?: boolean) => void;
+    getCanSomeRowsExpand: () => boolean;
+    getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
+    getIsSomeRowsExpanded: () => boolean;
+    getIsAllRowsExpanded: () => boolean;
+    getExpandedDepth: () => number;
+    getExpandedRowModel: () => RowModel<TGenerics>;
+    _getExpandedRowModel?: () => RowModel<TGenerics>;
+    getPreExpandedRowModel: () => RowModel<TGenerics>;
+};
+declare const Expanding: TableFeature;
+
+declare type ColumnSizingTableState = {
+    columnSizing: ColumnSizingState;
+    columnSizingInfo: ColumnSizingInfoState;
+};
+declare type ColumnSizingState = Record<string, number>;
+declare type ColumnSizingInfoState = {
+    startOffset: null | number;
+    startSize: null | number;
+    deltaOffset: null | number;
+    deltaPercentage: null | number;
+    isResizingColumn: false | string;
+    columnSizingStart: [string, number][];
+};
+declare type ColumnResizeMode = 'onChange' | 'onEnd';
+declare type ColumnSizingOptions = {
+    enableColumnResizing?: boolean;
+    columnResizeMode?: ColumnResizeMode;
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
+};
+declare type ColumnSizingDefaultOptions = {
+    columnResizeMode: ColumnResizeMode;
+    onColumnSizingChange: OnChangeFn<ColumnSizingState>;
+    onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
+};
+declare type ColumnSizingInstance<TGenerics extends TableGenerics> = {
+    setColumnSizing: (updater: Updater<ColumnSizingState>) => void;
+    setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void;
+    resetColumnSizing: (defaultState?: boolean) => void;
+    resetHeaderSizeInfo: (defaultState?: boolean) => void;
+    getTotalSize: () => number;
+    getLeftTotalSize: () => number;
+    getCenterTotalSize: () => number;
+    getRightTotalSize: () => number;
+};
+declare type ColumnSizingColumnDef = {
+    enableResizing?: boolean;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+};
+declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
+    getCanResize: () => boolean;
+    getIsResizing: () => boolean;
+    resetSize: () => void;
+};
+declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
+    getResizeHandler: () => (event: unknown) => void;
+};
+declare const defaultColumnSizing: {
+    size: number;
+    minSize: number;
+    maxSize: number;
+};
+declare const ColumnSizing: TableFeature;
+declare function passiveEventSupported(): boolean;
+
+declare type PaginationState = {
+    pageIndex: number;
+    pageSize: number;
+};
+declare type PaginationTableState = {
+    pagination: PaginationState;
+};
+declare type PaginationInitialTableState = {
+    pagination?: Partial<PaginationState>;
+};
+declare type PaginationOptions<TGenerics extends TableGenerics> = {
+    pageCount?: number;
+    manualPagination?: boolean;
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    autoResetPageIndex?: boolean;
+    getPaginationRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
+};
+declare type PaginationDefaultOptions = {
+    onPaginationChange: OnChangeFn<PaginationState>;
+};
+declare type PaginationInstance<TGenerics extends TableGenerics> = {
+    _autoResetPageIndex: () => void;
+    setPagination: (updater: Updater<PaginationState>) => void;
+    resetPagination: (defaultState?: boolean) => void;
+    setPageIndex: (updater: Updater<number>) => void;
+    resetPageIndex: (defaultState?: boolean) => void;
+    setPageSize: (updater: Updater<number>) => void;
+    resetPageSize: (defaultState?: boolean) => void;
+    setPageCount: (updater: Updater<number>) => void;
+    getPageOptions: () => number[];
+    getCanPreviousPage: () => boolean;
+    getCanNextPage: () => boolean;
+    previousPage: () => void;
+    nextPage: () => void;
+    getPrePaginationRowModel: () => RowModel<TGenerics>;
+    getPaginationRowModel: () => RowModel<TGenerics>;
+    _getPaginationRowModel?: () => RowModel<TGenerics>;
+    getPageCount: () => number;
+};
+declare const Pagination: TableFeature;
+
+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);
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+};
+declare type RowSelectionRow = {
+    getIsSelected: () => boolean;
+    getIsSomeSelected: () => boolean;
+    getCanSelect: () => boolean;
+    getCanMultiSelect: () => boolean;
+    getCanSelectSubRows: () => boolean;
+    toggleSelected: (value?: boolean) => void;
+    getToggleSelectedHandler: () => (event: unknown) => void;
+};
+declare type RowSelectionInstance<TGenerics extends TableGenerics> = {
+    getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
+    getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
+    setRowSelection: (updater: Updater<RowSelectionState>) => void;
+    resetRowSelection: (defaultState?: boolean) => void;
+    getIsAllRowsSelected: () => boolean;
+    getIsAllPageRowsSelected: () => boolean;
+    getIsSomeRowsSelected: () => boolean;
+    getIsSomePageRowsSelected: () => boolean;
+    toggleAllRowsSelected: (value?: boolean) => void;
+    toggleAllPageRowsSelected: (value?: boolean) => void;
+    getPreSelectedRowModel: () => RowModel<TGenerics>;
+    getSelectedRowModel: () => RowModel<TGenerics>;
+    getFilteredSelectedRowModel: () => RowModel<TGenerics>;
+    getGroupedSelectedRowModel: () => RowModel<TGenerics>;
+};
+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 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>>;
+};
+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'];
+};
+
+declare type Updater<T> = T | ((old: T) => T);
+declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
+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 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 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 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>>;
+declare type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+declare type Overwrite<T, U extends {
+    [TKey in keyof T]?: any;
+}> = Omit<T, keyof U> & U;
+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 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[];
+declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
+    key: any;
+    debug?: () => any;
+    onChange?: (result: TResult) => void;
+}): () => TResult;
+
+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;
+};
+declare type CoreTableState = {};
+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?: (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>>;
+    renderFallbackValue: any;
+};
+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>;
+};
+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>;
+}>;
+
+declare function getCoreRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+
+declare function getFilteredRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+
+declare function getFacetedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;
+
+declare function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;
+
+declare function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => undefined | [number, number];
+
+declare function getSortedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+
+declare function getGroupedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+
+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 getPaginationRowModel<TGenerics extends TableGenerics>(opts?: {
+    initialSync: boolean;
+}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
+
+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 };