@tanstack/table-core 8.0.12 → 8.1.0

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

@@ -1,63 +0,0 @@
-import { TableFeature } from '../core/instance';
-import { OnChangeFn, TableGenerics, Updater } from '../types';
-import { ColumnPinningPosition } from './Pinning';
-export declare type ColumnSizingTableState = {
-    columnSizing: ColumnSizingState;
-    columnSizingInfo: ColumnSizingInfoState;
-};
-export declare type ColumnSizingState = Record<string, number>;
-export declare type ColumnSizingInfoState = {
-    startOffset: null | number;
-    startSize: null | number;
-    deltaOffset: null | number;
-    deltaPercentage: null | number;
-    isResizingColumn: false | string;
-    columnSizingStart: [string, number][];
-};
-export declare type ColumnResizeMode = 'onChange' | 'onEnd';
-export declare type ColumnSizingOptions = {
-    enableColumnResizing?: boolean;
-    columnResizeMode?: ColumnResizeMode;
-    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
-    onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>;
-};
-export declare type ColumnSizingDefaultOptions = {
-    columnResizeMode: ColumnResizeMode;
-    onColumnSizingChange: OnChangeFn<ColumnSizingState>;
-    onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>;
-};
-export 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;
-};
-export declare type ColumnSizingColumnDef = {
-    enableResizing?: boolean;
-    size?: number;
-    minSize?: number;
-    maxSize?: number;
-};
-export declare type ColumnSizingColumn<TGenerics extends TableGenerics> = {
-    getSize: () => number;
-    getStart: (position?: ColumnPinningPosition) => number;
-    getCanResize: () => boolean;
-    getIsResizing: () => boolean;
-    resetSize: () => void;
-};
-export declare type ColumnSizingHeader<TGenerics extends TableGenerics> = {
-    getSize: () => number;
-    getStart: (position?: ColumnPinningPosition) => number;
-    getResizeHandler: () => (event: unknown) => void;
-};
-export declare const defaultColumnSizing: {
-    size: number;
-    minSize: number;
-    maxSize: number;
-};
-export declare const ColumnSizing: TableFeature;
-export declare function passiveEventSupported(): boolean;

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

@@ -1,39 +0,0 @@
-import { RowModel } from '..';
-import { TableFeature } from '../core/instance';
-import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
-export declare type ExpandedStateList = Record<string, boolean>;
-export declare type ExpandedState = true | Record<string, boolean>;
-export declare type ExpandedTableState = {
-    expanded: ExpandedState;
-};
-export declare type ExpandedRow = {
-    toggleExpanded: (expanded?: boolean) => void;
-    getIsExpanded: () => boolean;
-    getCanExpand: () => boolean;
-    getToggleExpandedHandler: () => () => void;
-};
-export 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;
-};
-export 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>;
-};
-export declare const Expanding: TableFeature;

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

@@ -1,90 +0,0 @@
-import { RowModel } from '..';
-import { TableFeature } from '../core/instance';
-import { BuiltInFilterFn } from '../filterFns';
-import { Column, OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
-import { Overwrite } from '../utils';
-export declare type FiltersTableState = {
-    columnFilters: ColumnFiltersState;
-    globalFilter: any;
-};
-export declare type ColumnFiltersState = ColumnFilter[];
-export declare type ColumnFilter = {
-    id: string;
-    value: unknown;
-};
-export declare type ResolvedColumnFilter<TGenerics extends TableGenerics> = {
-    id: string;
-    resolvedValue: unknown;
-    filterFn: FilterFn<TGenerics>;
-};
-export 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>;
-};
-export declare type TransformFilterValueFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => unknown;
-export declare type ColumnFilterAutoRemoveTestFn<TGenerics extends TableGenerics> = (value: any, column?: Column<TGenerics>) => boolean;
-export declare type CustomFilterFns<TGenerics extends TableGenerics> = Record<string, FilterFn<TGenerics>>;
-export declare type FilterFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInFilterFn | keyof TGenerics['FilterFns'] | FilterFn<TGenerics>;
-export declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
-    filterFn?: FilterFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
-    enableColumnFilter?: boolean;
-    enableGlobalFilter?: boolean;
-};
-export 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];
-};
-export declare type FiltersRow<TGenerics extends TableGenerics> = {
-    columnFilters: Record<string, boolean>;
-    columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
-};
-export 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];
-};
-export 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];
-};
-export declare const Filters: TableFeature;
-export declare function shouldAutoRemoveFilter<TGenerics extends TableGenerics>(filterFn?: FilterFn<TGenerics>, value?: any, column?: Column<TGenerics>): boolean;

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

@@ -1,68 +0,0 @@
-import { RowModel } from '..';
-import { BuiltInAggregationFn } from '../aggregationFns';
-import { TableFeature } from '../core/instance';
-import { Cell, Column, OnChangeFn, TableInstance, Row, Updater, Renderable, TableGenerics } from '../types';
-import { Overwrite } from '../utils';
-export declare type GroupingState = string[];
-export declare type GroupingTableState = {
-    grouping: GroupingState;
-};
-export declare type AggregationFn<TGenerics extends TableGenerics> = (columnId: string, leafRows: Row<TGenerics>[], childRows: Row<TGenerics>[]) => any;
-export declare type CustomAggregationFns<TGenerics extends TableGenerics> = Record<string, AggregationFn<TGenerics>>;
-export declare type AggregationFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInAggregationFn | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
-export declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
-    aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
-    aggregatedCell?: Renderable<TGenerics, {
-        instance: TableInstance<TGenerics>;
-        row: Row<TGenerics>;
-        column: Column<TGenerics>;
-        cell: Cell<TGenerics>;
-        getValue: () => TGenerics['Value'];
-    }>;
-    enableGrouping?: boolean;
-};
-export declare type GroupingColumn<TGenerics extends TableGenerics> = {
-    getCanGroup: () => boolean;
-    getIsGrouped: () => boolean;
-    getGroupedIndex: () => number;
-    toggleGrouping: () => void;
-    getToggleGroupingHandler: () => () => void;
-    getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined;
-    getAggregationFn: () => AggregationFn<TGenerics> | undefined;
-};
-export declare type GroupingRow = {
-    groupingColumnId?: string;
-    groupingValue?: any;
-    getIsGrouped: () => boolean;
-    _groupingValuesCache: Record<string, any>;
-};
-export declare type GroupingCell<TGenerics extends TableGenerics> = {
-    getIsGrouped: () => boolean;
-    getIsPlaceholder: () => boolean;
-    getIsAggregated: () => boolean;
-    renderAggregatedCell: () => string | null | TGenerics['Rendered'];
-};
-export declare type ColumnDefaultOptions = {
-    onGroupingChange: OnChangeFn<GroupingState>;
-    enableGrouping: boolean;
-};
-export 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';
-};
-export declare type GroupingColumnMode = false | 'reorder' | 'remove';
-export declare type GroupingInstance<TGenerics extends TableGenerics> = {
-    setGrouping: (updater: Updater<GroupingState>) => void;
-    resetGrouping: (defaultState?: boolean) => void;
-    getPreGroupedRowModel: () => RowModel<TGenerics>;
-    getGroupedRowModel: () => RowModel<TGenerics>;
-    _getGroupedRowModel?: () => RowModel<TGenerics>;
-};
-export declare const Grouping: TableFeature;
-export declare function orderColumns<TGenerics extends TableGenerics>(leafColumns: Column<TGenerics>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TGenerics>[];

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

@@ -1,18 +0,0 @@
-import { OnChangeFn, Updater, Column, TableGenerics } from '../types';
-import { TableFeature } from '../core/instance';
-export declare type ColumnOrderTableState = {
-    columnOrder: ColumnOrderState;
-};
-export declare type ColumnOrderState = string[];
-export declare type ColumnOrderOptions = {
-    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
-};
-export declare type ColumnOrderDefaultOptions = {
-    onColumnOrderChange: OnChangeFn<ColumnOrderState>;
-};
-export declare type ColumnOrderInstance<TGenerics extends TableGenerics> = {
-    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
-    resetColumnOrder: (defaultState?: boolean) => void;
-    _getOrderColumnsFn: () => (columns: Column<TGenerics>[]) => Column<TGenerics>[];
-};
-export declare const Ordering: TableFeature;

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

@@ -1,42 +0,0 @@
-import { TableFeature } from '../core/instance';
-import { OnChangeFn, TableGenerics, TableInstance, RowModel, Updater } from '../types';
-export declare type PaginationState = {
-    pageIndex: number;
-    pageSize: number;
-};
-export declare type PaginationTableState = {
-    pagination: PaginationState;
-};
-export declare type PaginationInitialTableState = {
-    pagination?: Partial<PaginationState>;
-};
-export declare type PaginationOptions<TGenerics extends TableGenerics> = {
-    pageCount?: number;
-    manualPagination?: boolean;
-    onPaginationChange?: OnChangeFn<PaginationState>;
-    autoResetPageIndex?: boolean;
-    getPaginationRowModel?: (instance: TableInstance<any>) => () => RowModel<any>;
-};
-export declare type PaginationDefaultOptions = {
-    onPaginationChange: OnChangeFn<PaginationState>;
-};
-export 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;
-};
-export declare const Pagination: TableFeature;

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

@@ -1,40 +0,0 @@
-import { TableFeature } from '../core/instance';
-import { OnChangeFn, Updater, Column, TableGenerics, Cell } from '../types';
-export declare type ColumnPinningPosition = false | 'left' | 'right';
-export declare type ColumnPinningState = {
-    left?: string[];
-    right?: string[];
-};
-export declare type ColumnPinningTableState = {
-    columnPinning: ColumnPinningState;
-};
-export declare type ColumnPinningOptions = {
-    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
-    enablePinning?: boolean;
-};
-export declare type ColumnPinningDefaultOptions = {
-    onColumnPinningChange: OnChangeFn<ColumnPinningState>;
-};
-export declare type ColumnPinningColumnDef = {
-    enablePinning?: boolean;
-};
-export declare type ColumnPinningColumn = {
-    getCanPin: () => boolean;
-    getPinnedIndex: () => number;
-    getIsPinned: () => ColumnPinningPosition;
-    pin: (position: ColumnPinningPosition) => void;
-};
-export declare type ColumnPinningRow<TGenerics extends TableGenerics> = {
-    getLeftVisibleCells: () => Cell<TGenerics>[];
-    getCenterVisibleCells: () => Cell<TGenerics>[];
-    getRightVisibleCells: () => Cell<TGenerics>[];
-};
-export declare type 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>[];
-};
-export declare const Pinning: TableFeature;

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

@@ -1,40 +0,0 @@
-import { TableFeature } from '../core/instance';
-import { OnChangeFn, TableGenerics, TableInstance, Row, RowModel, Updater } from '../types';
-export declare type RowSelectionState = Record<string, boolean>;
-export declare type RowSelectionTableState = {
-    rowSelection: RowSelectionState;
-};
-export 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>;
-};
-export declare type RowSelectionRow = {
-    getIsSelected: () => boolean;
-    getIsSomeSelected: () => boolean;
-    getCanSelect: () => boolean;
-    getCanMultiSelect: () => boolean;
-    getCanSelectSubRows: () => boolean;
-    toggleSelected: (value?: boolean) => void;
-    getToggleSelectedHandler: () => (event: unknown) => void;
-};
-export 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>;
-};
-export declare const RowSelection: TableFeature;
-export declare function selectRowsFn<TGenerics extends TableGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
-export declare function isRowSelected<TGenerics extends TableGenerics>(row: Row<TGenerics>, selection: Record<string, boolean>, instance: TableInstance<TGenerics>): boolean | 'some';

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

@@ -1,63 +0,0 @@
-import { RowModel } from '..';
-import { TableFeature } from '../core/instance';
-import { BuiltInSortingFn } from '../sortingFns';
-import { OnChangeFn, TableGenerics, TableInstance, Row, Updater } from '../types';
-import { Overwrite } from '../utils';
-export declare type SortDirection = 'asc' | 'desc';
-export declare type ColumnSort = {
-    id: string;
-    desc: boolean;
-};
-export declare type SortingState = ColumnSort[];
-export declare type SortingTableState = {
-    sorting: SortingState;
-};
-export declare type SortingFn<TGenerics extends TableGenerics> = {
-    (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
-};
-export declare type CustomSortingFns<TGenerics extends TableGenerics> = Record<string, SortingFn<TGenerics>>;
-export declare type SortingFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInSortingFn | keyof TGenerics['SortingFns'] | SortingFn<TGenerics>;
-export declare type SortingColumnDef<TGenerics extends TableGenerics> = {
-    sortingFn?: SortingFnOption<Overwrite<TGenerics, {
-        Value: any;
-    }>>;
-    sortDescFirst?: boolean;
-    enableSorting?: boolean;
-    enableMultiSort?: boolean;
-    invertSorting?: boolean;
-    sortUndefined?: false | -1 | 1;
-};
-export 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);
-};
-export 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;
-};
-export declare type SortingInstance<TGenerics extends TableGenerics> = {
-    setSorting: (updater: Updater<SortingState>) => void;
-    resetSorting: (defaultState?: boolean) => void;
-    getPreSortedRowModel: () => RowModel<TGenerics>;
-    getSortedRowModel: () => RowModel<TGenerics>;
-    _getSortedRowModel?: () => RowModel<TGenerics>;
-};
-export declare const Sorting: TableFeature;

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

@@ -1,40 +0,0 @@
-import { TableFeature } from '../core/instance';
-import { Cell, Column, OnChangeFn, TableGenerics, Updater } from '../types';
-export declare type VisibilityState = Record<string, boolean>;
-export declare type VisibilityTableState = {
-    columnVisibility: VisibilityState;
-};
-export declare type VisibilityOptions = {
-    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
-    enableHiding?: boolean;
-};
-export declare type VisibilityDefaultOptions = {
-    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
-};
-export 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;
-};
-export declare type VisibilityColumnDef = {
-    enableHiding?: boolean;
-};
-export declare type VisibilityRow<TGenerics extends TableGenerics> = {
-    _getAllVisibleCells: () => Cell<TGenerics>[];
-    getVisibleCells: () => Cell<TGenerics>[];
-};
-export declare type VisibilityColumn = {
-    getCanHide: () => boolean;
-    getIsVisible: () => boolean;
-    toggleVisibility: (value?: boolean) => void;
-    getToggleVisibilityHandler: () => (event: unknown) => void;
-};
-export declare const Visibility: TableFeature;

package/build/types/filterFns.d.ts

@@ -1,13 +0,0 @@
-import { FilterFn } from './features/Filters';
-export 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>;
-};
-export declare type BuiltInFilterFn = keyof typeof filterFns;

package/build/types/sortingFns.d.ts

@@ -1,11 +0,0 @@
-import { SortingFn } from './features/Sorting';
-export declare const reSplitAlphaNumeric: RegExp;
-export declare const sortingFns: {
-    alphanumeric: SortingFn<any>;
-    alphanumericCaseSensitive: SortingFn<any>;
-    text: SortingFn<any>;
-    textCaseSensitive: SortingFn<any>;
-    datetime: SortingFn<any>;
-    basic: SortingFn<any>;
-};
-export declare type BuiltInSortingFn = keyof typeof sortingFns;

package/build/types/types.d.ts

@@ -1,53 +0,0 @@
-import { CoreOptions, CoreTableState, CoreInstance } from './core/instance';
-import { CoreColumn, CoreColumnDef } from './core/column';
-import { VisibilityInstance, VisibilityTableState, VisibilityColumn as ColumnVisibilityColumn, VisibilityOptions, VisibilityColumnDef, VisibilityRow } from './features/Visibility';
-import { ColumnOrderInstance, ColumnOrderOptions, ColumnOrderTableState } from './features/Ordering';
-import { ColumnPinningColumn, ColumnPinningColumnDef, ColumnPinningInstance, ColumnPinningOptions, ColumnPinningRow, ColumnPinningTableState } from './features/Pinning';
-import { CoreHeader, CoreHeaderGroup, HeadersInstance } from './core/headers';
-import { FiltersColumn, FiltersColumnDef, FiltersInstance, FiltersOptions, FiltersRow, FiltersTableState } from './features/Filters';
-import { SortingColumn, SortingColumnDef, SortingInstance, SortingOptions, SortingTableState } from './features/Sorting';
-import { GroupingCell, GroupingColumn, GroupingColumnDef, GroupingInstance, GroupingOptions, GroupingRow, GroupingTableState } from './features/Grouping';
-import { ExpandedInstance, ExpandedOptions, ExpandedTableState, ExpandedRow } from './features/Expanding';
-import { ColumnSizingColumn, ColumnSizingColumnDef, ColumnSizingHeader, ColumnSizingInstance, ColumnSizingOptions, ColumnSizingTableState } from './features/ColumnSizing';
-import { PaginationInitialTableState, PaginationInstance, PaginationOptions, PaginationTableState } from './features/Pagination';
-import { RowSelectionInstance, RowSelectionOptions, RowSelectionRow, RowSelectionTableState } from './features/RowSelection';
-import { CoreRow } from './core/row';
-import { PartialKeys } from './utils';
-import { CoreCell } from './core/cell';
-export declare type Updater<T> = T | ((old: T) => T);
-export declare type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void;
-export declare type TableGenerics = {
-    Row?: any;
-    Value?: any;
-    FilterFns?: any;
-    SortingFns?: any;
-    AggregationFns?: any;
-    Renderer?: any;
-    Rendered?: any;
-    ColumnMeta?: any;
-    TableMeta?: any;
-    FilterMeta?: any;
-};
-export declare type AnyRender = (Comp: any, props: any) => any;
-export declare type TableInstance<TGenerics extends TableGenerics> = CoreInstance<TGenerics> & HeadersInstance<TGenerics> & VisibilityInstance<TGenerics> & ColumnOrderInstance<TGenerics> & ColumnPinningInstance<TGenerics> & FiltersInstance<TGenerics> & SortingInstance<TGenerics> & GroupingInstance<TGenerics> & ColumnSizingInstance<TGenerics> & ExpandedInstance<TGenerics> & PaginationInstance<TGenerics> & RowSelectionInstance<TGenerics>;
-export declare type TableOptionsResolved<TGenerics extends TableGenerics> = CoreOptions<TGenerics> & VisibilityOptions & ColumnOrderOptions & ColumnPinningOptions & FiltersOptions<TGenerics> & SortingOptions<TGenerics> & GroupingOptions<TGenerics> & ExpandedOptions<TGenerics> & ColumnSizingOptions & PaginationOptions<TGenerics> & RowSelectionOptions<TGenerics>;
-export declare type TableOptions<TGenerics extends TableGenerics> = Omit<PartialKeys<TableOptionsResolved<TGenerics>, 'state' | 'onStateChange'>, 'render' | 'renderFallbackValue'>;
-export declare type TableState = CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationTableState & RowSelectionTableState;
-export declare type InitialTableState = Partial<CoreTableState & VisibilityTableState & ColumnOrderTableState & ColumnPinningTableState & FiltersTableState & SortingTableState & ExpandedTableState & GroupingTableState & ColumnSizingTableState & PaginationInitialTableState & RowSelectionTableState>;
-export declare type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> & VisibilityRow<TGenerics> & ColumnPinningRow<TGenerics> & FiltersRow<TGenerics> & GroupingRow & RowSelectionRow & ExpandedRow;
-export declare type RowValues = {
-    [key: string]: any;
-};
-export declare type RowModel<TGenerics extends TableGenerics> = {
-    rows: Row<TGenerics>[];
-    flatRows: Row<TGenerics>[];
-    rowsById: Record<string, Row<TGenerics>>;
-};
-export declare type AccessorFn<TData> = (originalRow: TData, index: number) => any;
-export declare type Renderable<TGenerics extends TableGenerics, TProps> = string | ((props: TProps) => TGenerics['Rendered']);
-export declare type ColumnDef<TGenerics extends TableGenerics> = CoreColumnDef<TGenerics> & VisibilityColumnDef & ColumnPinningColumnDef & FiltersColumnDef<TGenerics> & SortingColumnDef<TGenerics> & GroupingColumnDef<TGenerics> & ColumnSizingColumnDef;
-export declare type Column<TGenerics extends TableGenerics> = CoreColumn<TGenerics> & ColumnVisibilityColumn & ColumnPinningColumn & FiltersColumn<TGenerics> & SortingColumn<TGenerics> & GroupingColumn<TGenerics> & ColumnSizingColumn<TGenerics>;
-export declare type Cell<TGenerics extends TableGenerics> = CoreCell<TGenerics> & GroupingCell<TGenerics>;
-export declare type Header<TGenerics extends TableGenerics> = CoreHeader<TGenerics> & ColumnSizingHeader<TGenerics>;
-export declare type HeaderGroup<TGenerics extends TableGenerics> = CoreHeaderGroup<TGenerics>;
-export declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];

package/build/types/utils/filterRowsUtils.d.ts

@@ -1,4 +0,0 @@
-import { TableGenerics, Row, RowModel, TableInstance } from '../types';
-export declare function filterRows<TGenerics extends TableGenerics>(rows: Row<TGenerics>[], filterRowImpl: (row: Row<TGenerics>) => any, instance: TableInstance<TGenerics>): RowModel<TGenerics>;
-export declare function filterRowModelFromLeafs<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRow: (row: Row<TGenerics>) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
-export declare function filterRowModelFromRoot<TGenerics extends TableGenerics>(rowsToFilter: Row<TGenerics>[], filterRow: (row: Row<TGenerics>) => any, instance: TableInstance<TGenerics>): RowModel<TGenerics>;

package/build/types/utils/getCoreRowModel.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getCoreRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getExpandedRowModel.d.ts

@@ -1,7 +0,0 @@
-import { TableInstance, Row, RowModel, TableGenerics } from '../types';
-export declare function getExpandedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
-export declare function expandRows<TGenerics extends TableGenerics>(rowModel: RowModel<TGenerics>, instance: TableInstance<TGenerics>): {
-    rows: Row<TGenerics>[];
-    flatRows: Row<TGenerics>[];
-    rowsById: Record<string, Row<TGenerics>>;
-};

package/build/types/utils/getFacetedMinMaxValues.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, TableGenerics } from '../types';
-export declare function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => undefined | [number, number];

package/build/types/utils/getFacetedRowModel.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getFacetedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => RowModel<TGenerics>;

package/build/types/utils/getFacetedUniqueValues.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, TableGenerics } from '../types';
-export declare function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>, columnId: string) => () => Map<any, number>;

package/build/types/utils/getFilteredRowModel.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getFilteredRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getGroupedRowModel.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getGroupedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getPaginationRowModel.d.ts

@@ -1,4 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getPaginationRowModel<TGenerics extends TableGenerics>(opts?: {
-    initialSync: boolean;
-}): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;

package/build/types/utils/getSortedRowModel.d.ts

@@ -1,2 +0,0 @@
-import { TableInstance, RowModel, TableGenerics } from '../types';
-export declare function getSortedRowModel<TGenerics extends TableGenerics>(): (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;