@tanstack/table-core 8.0.12 → 8.1.0

package/build/types/index.d.ts

@@ -1,29 +1,761 @@
-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 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 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;
+};
+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<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 = {
+    columnVisibility: VisibilityState;
+};
+declare type VisibilityOptions = {
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    enableHiding?: boolean;
+};
+declare type VisibilityDefaultOptions = {
+    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
+};
+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;
+    getIsAllColumnsVisible: () => boolean;
+    getIsSomeColumnsVisible: () => boolean;
+    getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+};
+declare type VisibilityColumnDef = {
+    enableHiding?: boolean;
+};
+declare type VisibilityRow<TData extends RowData> = {
+    _getAllVisibleCells: () => Cell<TData>[];
+    getVisibleCells: () => Cell<TData>[];
+};
+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<TData extends RowData> = {
+    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
+    resetColumnOrder: (defaultState?: boolean) => void;
+    _getOrderColumnsFn: () => (columns: Column<TData>[]) => Column<TData>[];
+};
+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<TData extends RowData> = {
+    getLeftVisibleCells: () => Cell<TData>[];
+    getCenterVisibleCells: () => Cell<TData>[];
+    getRightVisibleCells: () => Cell<TData>[];
+};
+declare type ColumnPinningInstance<TData extends RowData> = {
+    setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
+    resetColumnPinning: (defaultState?: boolean) => void;
+    getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean;
+    getLeftLeafColumns: () => Column<TData>[];
+    getRightLeafColumns: () => Column<TData>[];
+    getCenterLeafColumns: () => Column<TData>[];
+};
+declare const Pinning: TableFeature;
+
+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<TData extends RowData> = {
+    id: string;
+    resolvedValue: unknown;
+    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<TData extends RowData> = {
+    getAutoFilterFn: () => FilterFn<TData> | undefined;
+    getFilterFn: () => FilterFn<TData> | undefined;
+    setFilterValue: (updater: Updater<any>) => void;
+    getCanFilter: () => boolean;
+    getCanGlobalFilter: () => boolean;
+    getFacetedRowModel: () => RowModel<TData>;
+    _getFacetedRowModel?: () => RowModel<TData>;
+    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<TData extends RowData> = {
+    columnFilters: Record<string, boolean>;
+    columnFiltersMeta: Record<string, any>;
+};
+declare type FiltersOptions<TData extends RowData> = {
+    enableFilters?: boolean;
+    manualFiltering?: boolean;
+    filterFromLeafRows?: boolean;
+    getFilteredRowModel?: (table: Table<any>) => () => RowModel<any>;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    enableColumnFilters?: boolean;
+    globalFilterFn?: FilterFnOption<TData>;
+    onGlobalFilterChange?: OnChangeFn<any>;
+    enableGlobalFilter?: boolean;
+    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<TData extends RowData> = {
+    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
+    resetColumnFilters: (defaultState?: boolean) => void;
+    getPreFilteredRowModel: () => RowModel<TData>;
+    getFilteredRowModel: () => RowModel<TData>;
+    _getFilteredRowModel?: () => RowModel<TData>;
+    setGlobalFilter: (updater: Updater<any>) => void;
+    resetGlobalFilter: (defaultState?: boolean) => void;
+    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<TData extends RowData>(filterFn?: FilterFn<TData>, value?: any, column?: Column<TData>): 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<TData extends RowData> = {
+    (rowA: Row<TData>, rowB: Row<TData>, columnId: string): number;
+};
+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<TData extends RowData> = {
+    getAutoSortingFn: () => SortingFn<TData>;
+    getAutoSortDir: () => SortDirection;
+    getSortingFn: () => SortingFn<TData>;
+    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<TData extends RowData> = {
+    manualSorting?: boolean;
+    onSortingChange?: OnChangeFn<SortingState>;
+    enableSorting?: boolean;
+    enableSortingRemoval?: boolean;
+    enableMultiRemove?: boolean;
+    enableMultiSort?: boolean;
+    sortDescFirst?: boolean;
+    getSortedRowModel?: (table: Table<any>) => () => RowModel<any>;
+    maxMultiSortColCount?: number;
+    isMultiSortEvent?: (e: unknown) => boolean;
+};
+declare type SortingInstance<TData extends RowData> = {
+    setSorting: (updater: Updater<SortingState>) => void;
+    resetSorting: (defaultState?: boolean) => void;
+    getPreSortedRowModel: () => RowModel<TData>;
+    getSortedRowModel: () => RowModel<TData>;
+    _getSortedRowModel?: () => RowModel<TData>;
+};
+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<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<TData extends RowData> = {
+    getCanGroup: () => boolean;
+    getIsGrouped: () => boolean;
+    getGroupedIndex: () => number;
+    toggleGrouping: () => void;
+    getToggleGroupingHandler: () => () => void;
+    getAutoAggregationFn: () => AggregationFn<TData> | undefined;
+    getAggregationFn: () => AggregationFn<TData> | undefined;
+};
+declare type GroupingRow = {
+    groupingColumnId?: string;
+    groupingValue?: any;
+    getIsGrouped: () => boolean;
+    _groupingValuesCache: Record<string, any>;
+};
+declare type GroupingCell = {
+    getIsGrouped: () => boolean;
+    getIsPlaceholder: () => boolean;
+    getIsAggregated: () => boolean;
+};
+declare type ColumnDefaultOptions = {
+    onGroupingChange: OnChangeFn<GroupingState>;
+    enableGrouping: boolean;
+};
+declare type GroupingOptions = {
+    manualGrouping?: boolean;
+    onGroupingChange?: OnChangeFn<GroupingState>;
+    enableGrouping?: boolean;
+    getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>;
+    groupedColumnMode?: false | 'reorder' | 'remove';
+};
+declare type GroupingColumnMode = false | 'reorder' | 'remove';
+declare type GroupingInstance<TData extends RowData> = {
+    setGrouping: (updater: Updater<GroupingState>) => void;
+    resetGrouping: (defaultState?: boolean) => void;
+    getPreGroupedRowModel: () => RowModel<TData>;
+    getGroupedRowModel: () => RowModel<TData>;
+    _getGroupedRowModel?: () => RowModel<TData>;
+};
+declare const Grouping: TableFeature;
+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>;
+declare type ExpandedTableState = {
+    expanded: ExpandedState;
+};
+declare type ExpandedRow = {
+    toggleExpanded: (expanded?: boolean) => void;
+    getIsExpanded: () => boolean;
+    getCanExpand: () => boolean;
+    getToggleExpandedHandler: () => () => void;
+};
+declare type ExpandedOptions<TData extends RowData> = {
+    manualExpanding?: boolean;
+    onExpandedChange?: OnChangeFn<ExpandedState>;
+    autoResetExpanded?: boolean;
+    enableExpanding?: boolean;
+    getExpandedRowModel?: (table: Table<any>) => () => RowModel<any>;
+    getIsRowExpanded?: (row: Row<TData>) => boolean;
+    getRowCanExpand?: (row: Row<TData>) => boolean;
+    paginateExpandedRows?: boolean;
+};
+declare type ExpandedInstance<TData extends RowData> = {
+    _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<TData>;
+    _getExpandedRowModel?: () => RowModel<TData>;
+    getPreExpandedRowModel: () => RowModel<TData>;
+};
+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 = {
+    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 = {
+    getSize: () => number;
+    getStart: (position?: ColumnPinningPosition) => number;
+    getCanResize: () => boolean;
+    getIsResizing: () => boolean;
+    resetSize: () => void;
+};
+declare type ColumnSizingHeader = {
+    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 = {
+    pageCount?: number;
+    manualPagination?: boolean;
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    autoResetPageIndex?: boolean;
+    getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>;
+};
+declare type PaginationDefaultOptions = {
+    onPaginationChange: OnChangeFn<PaginationState>;
+};
+declare type PaginationInstance<TData extends RowData> = {
+    _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<TData>;
+    getPaginationRowModel: () => RowModel<TData>;
+    _getPaginationRowModel?: () => RowModel<TData>;
+    getPageCount: () => number;
+};
+declare const Pagination: TableFeature;
+
+declare type RowSelectionState = Record<string, boolean>;
+declare type RowSelectionTableState = {
+    rowSelection: RowSelectionState;
+};
+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 = {
+    getIsSelected: () => boolean;
+    getIsSomeSelected: () => boolean;
+    getIsAllSubRowsSelected: () => boolean;
+    getCanSelect: () => boolean;
+    getCanMultiSelect: () => boolean;
+    getCanSelectSubRows: () => boolean;
+    toggleSelected: (value?: boolean) => void;
+    getToggleSelectedHandler: () => (event: unknown) => void;
+};
+declare type RowSelectionInstance<TData extends RowData> = {
+    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<TData>;
+    getSelectedRowModel: () => RowModel<TData>;
+    getFilteredSelectedRowModel: () => RowModel<TData>;
+    getGroupedSelectedRowModel: () => RowModel<TData>;
+};
+declare const RowSelection: TableFeature;
+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>): boolean;
+declare function isSubRowSelected<TData extends RowData>(row: Row<TData>, selection: Record<string, boolean>, table: Table<TData>): boolean | 'some' | 'all';
+
+declare type CoreRow<TData extends RowData> = {
+    id: string;
+    index: number;
+    original?: TData;
+    depth: number;
+    _valuesCache: Record<string, any>;
+    getValue: (columnId: string) => any;
+    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;
+    ColumnMeta?: any;
+    TableMeta?: any;
+};
+declare type AnyRender = (Comp: any, props: any) => any;
+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<TData extends RowData> = CoreRow<TData> & VisibilityRow<TData> & ColumnPinningRow<TData> & FiltersRow<TData> & GroupingRow & RowSelectionRow & ExpandedRow;
+declare type RowValues = {
+    [key: string]: any;
+};
+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>>;
+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 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, 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[];
+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?: (table: any) => any;
+    getInitialState?: (initialState?: InitialTableState) => any;
+    createTable?: (table: any) => any;
+    getDefaultColumnDef?: () => 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<TData extends RowData> = {
+    data: TData[];
+    state: Partial<TableState>;
+    onStateChange: (updater: Updater<TableState>) => void;
+    debugAll?: boolean;
+    debugTable?: boolean;
+    debugHeaders?: boolean;
+    debugColumns?: boolean;
+    debugRows?: boolean;
+    initialState?: InitialTableState;
+    autoResetAll?: boolean;
+    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<TData extends RowData> = {
+    initialState: TableState;
+    reset: () => 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;
+    _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<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+
+declare function getFilteredRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+
+declare function getFacetedRowModel<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => RowModel<TData>;
+
+declare function getFacetedUniqueValues<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => Map<any, number>;
+
+declare function getFacetedMinMaxValues<TData extends RowData>(): (table: Table<TData>, columnId: string) => () => undefined | [number, number];
+
+declare function getSortedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+
+declare function getGroupedRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+
+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<TData extends RowData>(opts?: {
+    initialSync: boolean;
+}): (table: Table<TData>) => () => RowModel<TData>;
+
+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, isSubRowSelected, makeStateUpdater, memo, noop, orderColumns, passiveEventSupported, reSplitAlphaNumeric, selectRowsFn, shouldAutoRemoveFilter, sortingFns };