@tanstack/react-table 0.0.1-alpha.6 → 8.0.0-alpha.1

package/build/types/core.d.ts

@@ -0,0 +1,122 @@
+import { RequiredKeys } from './utils';
+import { Updater, PropGetterValue, Options, TableState, ColumnDef, Row, Column, Cell, Header, AccessorFn, TableProps, TableBodyProps, PropGetter, Getter, RowProps, CellProps, ReactTable, RowValues, Renderable } from './types';
+import { RowModel } from '.';
+export declare type CoreOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    data: TData[];
+    columns: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    debug?: boolean;
+    defaultColumn?: Partial<ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    initialState?: Partial<TableState>;
+    state?: Partial<TableState>;
+    getSubRows?: (originalRow: TData, index: number) => TData[];
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => string;
+    onStateChange?: (newState: TableState) => void;
+};
+export declare type TableCore<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    rerender: () => void;
+    initialState: TableState;
+    internalState: TableState;
+    reset: () => void;
+    options: RequiredKeys<Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, 'state'>;
+    updateOptions: (newOptions: Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => void;
+    getRowId: (_: TData, index: number, parent?: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => string;
+    getState: () => TableState;
+    setState: (updater: Updater<TableState>) => void;
+    getDefaultColumn: () => Partial<ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getColumnDefs: () => ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    createColumn: (columnDef: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, depth: number, parent?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getAllColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getAllFlatColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getAllFlatColumnsById: () => Record<string, Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getAllLeafColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getColumn: (columnId: string) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getColumnWidth: (columnId: string) => number;
+    getTotalWidth: () => number;
+    createCell: (row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, value: any) => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    createRow: (id: string, original: TData | undefined, rowIndex: number, depth: number, values: Record<string, any>) => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getCoreRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getCoreRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCoreFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCoreRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getRow: (id: string) => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getCell: (rowId: string, columnId: string) => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getTableProps: PropGetter<TableProps>;
+    getTableBodyProps: PropGetter<TableBodyProps>;
+    getRowProps: <TGetter extends Getter<RowProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<RowProps, TGetter>;
+    getCellProps: <TGetter extends Getter<CellProps>>(rowId: string, columnId: string, userProps?: TGetter) => undefined | PropGetterValue<CellProps, TGetter>;
+};
+export declare type CoreRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    id: string;
+    index: number;
+    original?: TData;
+    depth: number;
+    values: RowValues;
+    leafRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    subRows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRowProps: PropGetter<RowProps>;
+    originalSubRows?: TData[];
+    getAllCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getAllCellsByColumnId: () => Record<string, Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare type CoreColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = ({
+    accessorFn: AccessorFn<TData>;
+    id: string;
+    accessorKey?: never;
+    header?: string | Renderable<{
+        header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    }>;
+} | {
+    accessorKey: string & keyof TData;
+    id?: string;
+    accessorFn?: never;
+    header?: string | Renderable<{
+        header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    }>;
+} | {
+    id: string;
+    accessorKey?: never;
+    accessorFn?: never;
+    header?: string | Renderable<{
+        header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    }>;
+} | {
+    header: string;
+    id?: string;
+    accessorKey?: never;
+    accessorFn?: never;
+}) & {
+    __generated: true;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    columns?: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    footer?: Renderable<{
+        header: Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    }>;
+    cell?: Renderable<{
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        cell: Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        value: TValue;
+    }>;
+    defaultIsVisible?: boolean;
+};
+export declare type CoreColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    id: string;
+    depth: number;
+    accessorFn?: AccessorFn<TData>;
+    columnDef: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getWidth: () => number;
+    columns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    parent?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getFlatColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeafColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare function createTableInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(options: Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, rerender: () => void): ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;

package/build/types/createTable.d.ts

@@ -0,0 +1,35 @@
+import { Cell, Column, Row } from '.';
+import { ReactTable, ColumnDef, AccessorFn, Options } from './types';
+import { Overwrite } from './utils';
+declare type TableHelper<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    RowType: <TTData>() => TableHelper<TTData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    FilterFns: <TTFilterFns>(filterFns: TTFilterFns) => TableHelper<TData, TValue, TTFilterFns, TSortingFns, TAggregationFns>;
+    SortingFns: <TTSortingFns>(sortingFns: TTSortingFns) => TableHelper<TData, TValue, TFilterFns, TTSortingFns, TAggregationFns>;
+    AggregationFns: <TTAggregationFns>(aggregationFns: TTAggregationFns) => TableHelper<TData, TValue, TFilterFns, TSortingFns, TTAggregationFns>;
+    createColumns: (columns: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]) => ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    createGroup: (column: Overwrite<ColumnDef<TData, unknown, TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+    }>) => ColumnDef<TData, unknown, TFilterFns, TSortingFns, TAggregationFns>;
+    createColumn: <TAccessor extends AccessorFn<TData> | keyof TData>(accessor: TAccessor, column: TAccessor extends (...args: any[]) => any ? Overwrite<ColumnDef<TData, ReturnType<TAccessor>, TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+        id: string;
+    }> : TAccessor extends keyof TData ? Overwrite<ColumnDef<TData, TData[TAccessor], TFilterFns, TSortingFns, TAggregationFns>, {
+        __generated?: never;
+        accessorFn?: never;
+        accessorKey?: never;
+    }> : never) => ColumnDef<TData, TAccessor extends (...args: any[]) => any ? ReturnType<TAccessor> : TAccessor extends keyof TData ? TData[TAccessor] : never, TFilterFns, TSortingFns, TAggregationFns>;
+    useTable: <TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(options: Options<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    types: {
+        instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        columnDef: ColumnDef<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+        cell: Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    };
+};
+export declare function createTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(): TableHelper<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export {};

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

@@ -0,0 +1,52 @@
+import { MouseEvent, TouchEvent } from 'react';
+import { RowModel } from '..';
+import { Getter, OnChangeFn, PropGetterValue, ReactTable, 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;
+    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+};
+export declare type ExpandedOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    onExpandedChange?: OnChangeFn<ExpandedState>;
+    autoResetExpanded?: boolean;
+    enableExpanded?: boolean;
+    expandRowsFn?: (instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, expandedState: ExpandedState, groupedRowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    expandSubRows?: boolean;
+    defaultCanExpand?: boolean;
+    getIsRowExpanded?: (row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+    getRowCanExpand?: (row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+    paginateExpandedRows?: boolean;
+};
+export declare type ToggleExpandedProps = {
+    title?: string;
+    onClick?: (event: MouseEvent | TouchEvent) => void;
+};
+export declare type ExpandedInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    setExpanded: (updater: Updater<ExpandedState>) => void;
+    toggleRowExpanded: (rowId: string, expanded?: boolean) => void;
+    toggleAllRowsExpanded: (expanded?: boolean) => void;
+    resetExpanded: () => void;
+    getRowCanExpand: (rowId: string) => boolean;
+    getIsRowExpanded: (rowId: string) => boolean;
+    getToggleExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(rowId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getToggleAllRowsExpandedProps: <TGetter extends Getter<ToggleExpandedProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleExpandedProps, TGetter>;
+    getIsAllRowsExpanded: () => boolean;
+    getExpandedDepth: () => number;
+    getExpandedRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreExpandedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreExpandedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreExpandedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getExpandedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getExpandedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getExpandedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getInitialState(): ExpandedTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ExpandedOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ExpandedInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ExpandedRow;

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

@@ -0,0 +1,93 @@
+import { RowModel } from '..';
+import { BuiltInFilterType } from '../filterTypes';
+import { Column, OnChangeFn, ReactTable, Row, Updater } from '../types';
+export declare type ColumnFilter = {
+    id: string;
+    value: unknown;
+};
+export declare type ColumnFiltersState = ColumnFilter[];
+export declare type FilterFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    (rows: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], columnIds: string[], filterValue: any): any;
+    autoRemove?: ColumnFilterAutoRemoveTestFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+};
+export declare type ColumnFilterAutoRemoveTestFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = (value: unknown, column?: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+export declare type CustomFilterTypes<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = Record<string, FilterFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+export declare type FiltersTableState = {
+    columnFilters: ColumnFiltersState;
+    globalFilter: any;
+};
+export declare type FilterType<TFilterFns> = 'auto' | BuiltInFilterType | keyof TFilterFns | FilterFn<unknown, unknown, TFilterFns, any, any>;
+export declare type FiltersColumnDef<TFilterFns> = {
+    filterType?: FilterType<TFilterFns>;
+    enableAllFilters?: boolean;
+    enableColumnFilter?: boolean;
+    enableGlobalFilter?: boolean;
+    defaultCanFilter?: boolean;
+    defaultCanColumnFilter?: boolean;
+    defaultCanGlobalFilter?: boolean;
+};
+export declare type FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    filterType: FilterType<TFilterFns>;
+    getCanColumnFilter: () => boolean;
+    getCanGlobalFilter: () => boolean;
+    getColumnFilterIndex: () => number;
+    getIsColumnFiltered: () => boolean;
+    getColumnFilterValue: () => unknown;
+    setColumnFilterValue: (value: any) => void;
+    getPreFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[] | undefined;
+    getPreFilteredUniqueValues: () => Map<any, number>;
+    getPreFilteredMinMaxValues: () => [any, any];
+};
+export declare type FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    filterFromChildrenUp?: boolean;
+    filterTypes?: TFilterFns;
+    enableFilters?: boolean;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    autoResetColumnFilters?: boolean;
+    enableColumnFilters?: boolean;
+    columnFilterRowsFn?: (instance: ReactTable<any, any, any, any, any>, columnFilters: ColumnFiltersState, coreRowModel: RowModel<any, any, any, any, any>) => RowModel<any, any, any, any, any>;
+    globalFilterType?: FilterType<TFilterFns>;
+    onGlobalFilterChange?: OnChangeFn<any>;
+    enableGlobalFilters?: boolean;
+    autoResetGlobalFilter?: boolean;
+    enableGlobalFilter?: boolean;
+    globalFilterRowsFn?: (instance: ReactTable<any, any, any, any, any>, globalFilter: any, columnFilteredRowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getColumnCanGlobalFilterFn?: (column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+};
+export declare type FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    getColumnAutoFilterFn: (columnId: string) => FilterFn<any, any, any, any, any> | undefined;
+    getColumnFilterFn: (columnId: string) => FilterFn<any, any, any, any, any> | undefined;
+    setColumnFilters: (updater: Updater<ColumnFiltersState>) => void;
+    setColumnFilterValue: (columnId: string, value: any) => void;
+    resetColumnFilters: () => void;
+    getColumnCanColumnFilter: (columnId: string) => boolean;
+    getColumnCanGlobalFilterFn?: (column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => boolean;
+    getColumnIsFiltered: (columnId: string) => boolean;
+    getColumnFilterValue: (columnId: string) => unknown;
+    getColumnFilterIndex: (columnId: string) => number;
+    getColumnFilteredRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreColumnFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreColumnFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreColumnFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getColumnFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getColumnFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getColumnFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    setGlobalFilter: (updater: Updater<any>) => void;
+    resetGlobalFilter: () => void;
+    getGlobalAutoFilterFn: () => FilterFn<any, any, any, any, any> | undefined;
+    getGlobalFilterFn: () => FilterFn<any, any, any, any, any> | undefined;
+    getColumnCanGlobalFilter: (columnId: string) => boolean;
+    getGlobalFilteredRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreGlobalFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGlobalFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGlobalFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getGlobalFilteredRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGlobalFilteredFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGlobalFilteredRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getDefaultColumn<TFilterFns>(): FiltersColumnDef<TFilterFns>;
+export declare function getInitialState(): FiltersTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): FiltersOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): FiltersColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): FiltersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function shouldAutoRemoveFilter(filterFn?: FilterFn<any, any, any, any, any>, value?: any, column?: Column<any, any, any, any, any>): boolean;

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

@@ -0,0 +1,82 @@
+import React, { MouseEvent, TouchEvent } from 'react';
+import { RowModel } from '..';
+import { BuiltInAggregationType } from '../aggregationTypes';
+import { Cell, Column, Getter, OnChangeFn, PropGetterValue, ReactTable, Row, Updater } from '../types';
+export declare type GroupingState = string[];
+export declare type AggregationFn = (leafValues: any[], childValues: any[]) => any;
+export declare type AggregationType<TAggregationFns> = 'auto' | BuiltInAggregationType | keyof TAggregationFns | AggregationFn;
+export declare type GroupingTableState = {
+    grouping: GroupingState;
+};
+export declare type GroupingColumnDef<TAggregationFns> = {
+    aggregationType?: AggregationType<TAggregationFns>;
+    aggregateValue?: (columnValue: unknown) => any;
+    renderAggregatedCell?: () => React.ReactNode;
+    enableGrouping?: boolean;
+    defaultCanGroup?: boolean;
+    getCanGroup?: unknown;
+};
+export declare type GroupingColumn<_TData, _TValue, _TFilterFns, _TSortingFns, TAggregationFns> = {
+    aggregationType?: AggregationType<TAggregationFns>;
+    getCanGroup: () => boolean;
+    getIsGrouped: () => boolean;
+    getGroupedIndex: () => number;
+    toggleGrouping: () => void;
+    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
+};
+export declare type GroupingRow = {
+    groupingColumnId?: string;
+    groupingValue?: any;
+    getIsGrouped: () => boolean;
+};
+export declare type GroupingCell = {
+    getIsGrouped: () => boolean;
+    getIsPlaceholder: () => boolean;
+    getIsAggregated: () => boolean;
+};
+export declare type ColumnDefaultOptions = {
+    onGroupingChange: OnChangeFn<GroupingState>;
+    autoResetGrouping: boolean;
+    enableGrouping: boolean;
+};
+export declare type GroupingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    aggregationTypes?: TAggregationFns;
+    onGroupingChange?: OnChangeFn<GroupingState>;
+    autoResetGrouping?: boolean;
+    enableGrouping?: boolean;
+    enableGroupingRemoval?: boolean;
+    groupRowsFn?: (instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, groupingState: GroupingState, sortedRowsModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    groupedColumnMode?: false | 'reorder' | 'remove';
+};
+export declare type GroupingColumnMode = false | 'reorder' | 'remove';
+export declare type ToggleGroupingProps = {
+    title?: string;
+    onClick?: (event: MouseEvent | TouchEvent) => void;
+};
+export declare type GroupingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    getColumnAutoAggregationFn: (columnId: string) => AggregationFn | undefined;
+    getColumnAggregationFn: (columnId: string) => AggregationFn | undefined;
+    setGrouping: (updater: Updater<GroupingState>) => void;
+    resetGrouping: () => void;
+    toggleColumnGrouping: (columnId: string) => void;
+    getColumnCanGroup: (columnId: string) => boolean;
+    getColumnIsGrouped: (columnId: string) => boolean;
+    getColumnGroupedIndex: (columnId: string) => number;
+    getToggleGroupingProps: <TGetter extends Getter<ToggleGroupingProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleGroupingProps, TGetter>;
+    getRowIsGrouped: (rowId: string) => boolean;
+    getGroupedRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreGroupedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGroupedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreGroupedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getGroupedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGroupedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getGroupedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getDefaultColumn<TFilterFns>(): GroupingColumnDef<TFilterFns>;
+export declare function getInitialState(): GroupingTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingRow;
+export declare function createCell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(cell: Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> & GroupingCell, column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, _instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): GroupingCell;
+export declare function orderColumns<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(leafColumns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], grouping: string[], groupedColumnMode?: GroupingColumnMode): Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];

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

@@ -0,0 +1,41 @@
+import { Cell, Column, FooterGroupProps, FooterProps, Getter, Header, HeaderGroup, HeaderGroupProps, HeaderProps, PropGetterValue, ReactTable, Row } from '../types';
+export declare type HeadersRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    _getAllVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare type HeadersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    createHeader: (column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, options: {
+        id?: string;
+        isPlaceholder?: boolean;
+        placeholderId?: string;
+        depth: number;
+    }) => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightHeaderGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightFooterGroups: () => HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightFlatHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getLeftLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getCenterLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getRightLeafHeaders: () => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getHeader: (id: string) => Header<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getHeaderGroupProps: <TGetter extends Getter<HeaderGroupProps>>(id: string, userProps?: TGetter) => undefined | PropGetterValue<HeaderGroupProps, TGetter>;
+    getFooterGroupProps: <TGetter extends Getter<FooterGroupProps>>(id: string, userProps?: TGetter) => undefined | PropGetterValue<FooterGroupProps, TGetter>;
+    getHeaderProps: <TGetter extends Getter<HeaderProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<HeaderProps, TGetter>;
+    getFooterProps: <TGetter extends Getter<FooterProps>>(headerId: string, userProps?: TGetter) => undefined | PropGetterValue<FooterProps, TGetter>;
+    getTotalWidth: () => number;
+};
+export declare function createRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(row: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): HeadersRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): HeadersInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function buildHeaderGroups<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(allColumns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], columnsToGroup: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[], instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, headerFamily?: 'center' | 'left' | 'right'): HeaderGroup<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];

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

@@ -0,0 +1,19 @@
+import { ReactTable, OnChangeFn, Updater, Column } from '../types';
+export declare type ColumnOrderState = string[];
+export declare type ColumnOrderTableState = {
+    columnOrder: string[];
+};
+export declare type ColumnOrderOptions = {
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+};
+export declare type ColumnOrderDefaultOptions = {
+    onColumnOrderChange: OnChangeFn<ColumnOrderState>;
+};
+export declare type ColumnOrderInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    setColumnOrder: (updater: Updater<ColumnOrderState>) => void;
+    resetColumnOrder: () => void;
+    getOrderColumnsFn: () => (columns: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[]) => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare function getInitialState(): ColumnOrderTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnOrderDefaultOptions;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnOrderInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;

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

@@ -0,0 +1,39 @@
+import { OnChangeFn, Updater, ReactTable, Column } from '../types';
+declare type ColumnPinningPosition = 'left' | 'right' | 'both';
+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;
+    defaultCanPin?: boolean;
+};
+export declare type ColumnPinningColumn = {
+    getCanPin: () => boolean;
+    getPinnedIndex: () => number;
+    getIsPinned: () => false | ColumnPinningPosition;
+    pin: (position: ColumnPinningPosition) => void;
+};
+export declare type ColumnPinningInstance<_TData, _TValue, _TFilterFns, _TSortingFns, _TAggregationFns> = {
+    setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
+    resetColumnPinning: () => void;
+    pinColumn: (columnId: string, position: ColumnPinningPosition) => void;
+    getColumnCanPin: (columnId: string) => boolean;
+    getColumnIsPinned: (columnId: string) => false | ColumnPinningPosition;
+    getColumnPinnedIndex: (columnId: string) => number;
+};
+export declare function getInitialState(): ColumnPinningTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnPinningDefaultOptions;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnPinningColumn;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): ColumnPinningInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export {};

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

@@ -0,0 +1,75 @@
+import { MouseEvent, TouchEvent } from 'react';
+import { RowModel } from '..';
+import { BuiltInSortType } from '../sortTypes';
+import { Column, Getter, OnChangeFn, PropGetterValue, ReactTable, Row, Updater } from '../types';
+export declare type ColumnSort = {
+    id: string;
+    desc: boolean;
+};
+export declare type SortingState = ColumnSort[];
+export declare type SortingFn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    (rowA: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, rowB: Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, columnId: string): number;
+};
+export declare type SortingTableState = {
+    sorting: SortingState;
+};
+export declare type SortType<TSortingFns> = 'auto' | BuiltInSortType | keyof TSortingFns | SortingFn<any, any, any, TSortingFns, any>;
+export declare type SortingColumnDef<TFilterFns> = {
+    sortType?: SortType<TFilterFns>;
+    sortDescFirst?: boolean;
+    enableSorting?: boolean;
+    enableMultiSort?: boolean;
+    defaultCanSort?: boolean;
+    invertSorting?: boolean;
+    sortUndefined?: false | -1 | 1;
+};
+export declare type SortingColumn<_TData, _TValue, TFilterFns, _TSortingFns, _TAggregationFns> = {
+    sortType: SortType<TFilterFns>;
+    getCanSort: () => boolean;
+    getCanMultiSort: () => boolean;
+    getSortIndex: () => number;
+    getIsSorted: () => false | 'asc' | 'desc';
+    toggleSorting: (desc?: boolean, isMulti?: boolean) => void;
+    getToggleSortingProps: <TGetter extends Getter<ToggleSortingProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleSortingProps, TGetter>;
+};
+export declare type SortingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    sortTypes?: TSortingFns;
+    onSortingChange?: OnChangeFn<SortingState>;
+    autoResetSorting?: boolean;
+    enableSorting?: boolean;
+    enableSortingRemoval?: boolean;
+    enableMultiRemove?: boolean;
+    enableMultiSort?: boolean;
+    sortDescFirst?: boolean;
+    sortRowsFn?: (instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, sortingState: SortingState, globalFilteredRowModel: RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>) => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    maxMultiSortColCount?: number;
+    isMultiSortEvent?: (e: MouseEvent | TouchEvent) => boolean;
+};
+export declare type ToggleSortingProps = {
+    title?: string;
+    onClick?: (event: MouseEvent | TouchEvent) => void;
+};
+export declare type SortingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    getColumnAutoSortingFn: (columnId: string) => SortingFn<any, any, any, any, any> | undefined;
+    getColumnSortingFn: (columnId: string) => SortingFn<any, any, any, any, any> | undefined;
+    setSorting: (updater: Updater<SortingState>) => void;
+    toggleColumnSorting: (columnId: string, desc?: boolean, multi?: boolean) => void;
+    resetSorting: () => void;
+    getColumnCanSort: (columnId: string) => boolean;
+    getColumnCanMultiSort: (columnId: string) => boolean;
+    getColumnIsSorted: (columnId: string) => false | 'asc' | 'desc';
+    getColumnSortIndex: (columnId: string) => number;
+    getToggleSortingProps: <TGetter extends Getter<ToggleSortingProps>>(columnId: string, userProps?: TGetter) => undefined | PropGetterValue<ToggleSortingProps, TGetter>;
+    getSortedRowModel: () => RowModel<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+    getPreSortedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreSortedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getPreSortedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+    getSortedRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getSortedFlatRows: () => Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getSortedRowsById: () => Record<string, Row<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>>;
+};
+export declare function getDefaultColumn<TFilterFns>(): SortingColumnDef<TFilterFns>;
+export declare function getInitialState(): SortingTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): SortingOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): SortingColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): SortingInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;

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

@@ -0,0 +1,47 @@
+import { Cell, Column, Getter, OnChangeFn, PropGetterValue, ReactTable, Updater } from '../types';
+export declare type VisibilityOptions = {
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    enableHiding?: boolean;
+};
+export declare type VisibilityDefaultOptions = {
+    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
+};
+export declare type VisibilityState = Record<string, boolean>;
+export declare type VisibilityTableState = {
+    columnVisibility: VisibilityState;
+};
+export declare type VisibilityInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    getVisibleFlatColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    getVisibleLeafColumns: () => Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+    setColumnVisibility: (updater: Updater<VisibilityState>) => void;
+    toggleColumnVisibility: (columnId: string, value?: boolean) => void;
+    toggleAllColumnsVisible: (value?: boolean) => void;
+    getColumnIsVisible: (columId: string) => boolean;
+    getColumnCanHide: (columnId: string) => boolean;
+    getIsAllColumnsVisible: () => boolean;
+    getIsSomeColumnsVisible: () => boolean;
+    getToggleAllColumnsVisibilityProps: <TGetter extends Getter<ToggleAllColumnsVisibilityProps>>(userProps?: TGetter) => undefined | PropGetterValue<ToggleAllColumnsVisibilityProps, TGetter>;
+};
+declare type ToggleVisibilityProps = {};
+declare type ToggleAllColumnsVisibilityProps = {};
+export declare type VisibilityColumnDef = {
+    enableHiding?: boolean;
+    defaultCanHide?: boolean;
+};
+export declare type VisibilityRow<TData, TValue, TFilterFns, TSortingFns, TAggregationFns> = {
+    getVisibleCells: () => Cell<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>[];
+};
+export declare type VisibilityColumn = {
+    getCanHide: () => boolean;
+    getIsVisible: () => boolean;
+    toggleVisibility: (value?: boolean) => void;
+    getToggleVisibilityProps: <TGetter extends Getter<ToggleVisibilityProps>>(userProps?: TGetter) => PropGetterValue<ToggleVisibilityProps, TGetter>;
+};
+export declare function getInitialState(): VisibilityTableState;
+export declare function getDefaultOptions<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): VisibilityDefaultOptions;
+export declare function getDefaultColumn(): {
+    defaultIsVisible: boolean;
+};
+export declare function createColumn<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(column: Column<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>, instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): VisibilityColumn;
+export declare function getInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>(instance: ReactTable<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>): VisibilityInstance<TData, TValue, TFilterFns, TSortingFns, TAggregationFns>;
+export {};