@itwin/itwinui-react 3.0.0-dev.0 → 3.0.0-dev.10

package/esm/react-table/react-table.d.ts

@@ -0,0 +1,745 @@
+import type { ChangeEvent, ComponentType, CSSProperties, DependencyList, EffectCallback, MouseEvent, ReactElement, ReactFragment, ReactNode } from 'react';
+export type FieldType = 'text' | 'number' | 'date' | string;
+export type CellRendererProps<D extends Record<string, unknown> = {}> = {
+    /**
+     * Cell HTML props passed from the Table.
+     */
+    cellElementProps: TableCellProps;
+    /**
+     * Table specific cell props like `column`, `row`.
+     */
+    cellProps: CellProps<D>;
+    /**
+     * Cell's content.
+     */
+    children: React.ReactNode;
+    /**
+     * Function that returns whether the cell is disabled.
+     */
+    isDisabled?: (rowData: D) => boolean;
+};
+export type TableFilterProps<T extends Record<string, unknown>> = FilterProps<T> & {
+    /**
+     * Data of column on which filter is opened. It is provided by the table it self.
+     */
+    column: HeaderGroup<T>;
+    /**
+     * Function to close the filter. It is provided by the table it self.
+     */
+    close: () => void;
+    /**
+     * Function to set the filter value. It is provided by the table it self.
+     */
+    setFilter: (filterValue: unknown | undefined) => void;
+    /**
+     * Function to clear the filter value. It is provided by the table it self.
+     */
+    clearFilter: () => void;
+};
+export interface TableOptions<D extends Record<string, unknown>> extends Omit<UseTableOptions<D>, 'data' | 'columns'>, UseRowSelectOptions<D>, UseExpandedOptions<D>, UseFiltersOptions<D>, UsePaginationOptions<D>, UseGlobalFiltersOptions<D>, UseGlobalFiltersColumnOptions<D>, Omit<UseResizeColumnsOptions<D>, 'disableResizing'>, UseSortByOptions<D> {
+    /**
+     * List of columns.
+     *
+     * Should not have a top-level `Header` or a `columns` sub-property. They are only allowed to be passed for backwards compatibility.
+     * See [migration guide](https://github.com/iTwin/iTwinUI/wiki/iTwinUI-react-v2-migration-guide#breaking-changes).
+     */
+    columns: Array<Column<D>>;
+    /**
+     * Table data list.
+     * Must be memoized.
+     *
+     * Supports expandable sub-rows using the `subRows` field in data entries.
+     * If some rows don't have sub-data, it is recommended to pass an empty array to `subRows` for consistent spacing.
+     */
+    data: D[];
+    /**
+     * Column's resize mode.
+     *  - `fit` - when resizing it affects current and the next column,
+     *   e.g. when increasing width of current column, next column's width will decrease.
+     *  - `expand` - when resizing it affects only the current column,
+     *   e.g. when increasing width of the current column, next column's width remains the same.
+     * @default 'fit'
+     */
+    columnResizeMode?: 'fit' | 'expand';
+}
+export interface TableInstance<D extends Record<string, unknown> = {}> extends Omit<TableOptions<D>, 'columns' | 'pageCount'>, UseTableInstanceProps<D>, UseColumnOrderInstanceProps<D>, UseExpandedInstanceProps<D>, UseFiltersInstanceProps<D>, UseGlobalFiltersInstanceProps<D>, UseGroupByInstanceProps<D>, UsePaginationInstanceProps<D>, UseRowSelectInstanceProps<D>, UseRowStateInstanceProps<D>, UseSortByInstanceProps<D> {
+    initialRows: Row<D>[];
+    columnResizeMode: TableOptions<D>['columnResizeMode'];
+    tableWidth: number;
+}
+export interface TableState<D extends Record<string, unknown> = {}> extends UseColumnOrderState<D>, UseExpandedState<D>, UseFiltersState<D>, UseGlobalFiltersState<D>, UseGroupByState<D>, UsePaginationState<D>, UseRowSelectState<D>, UseRowStateState<D>, UseSortByState<D> {
+    hiddenColumns?: Array<IdType<D>> | undefined;
+    columnResizing: {
+        startX?: number;
+        columnWidth?: number;
+        nextColumnWidth?: number;
+        headerIdWidths?: Array<[string, number]>;
+        nextHeaderIdWidths?: Array<[string, number]>;
+        columnWidths: Record<string, number>;
+        isResizingColumn?: string;
+    };
+    isTableResizing?: boolean;
+    columnReorderStartIndex: number;
+    sticky: {
+        isScrolledToRight?: boolean;
+        isScrolledToLeft?: boolean;
+    };
+    lastSelectedRowId?: string;
+}
+export interface Hooks<D extends Record<string, unknown> = {}> extends UseTableHooks<D>, UseExpandedHooks<D>, UseGroupByHooks<D>, UseRowSelectHooks<D>, UseSortByHooks<D> {
+}
+export interface Cell<D extends Record<string, unknown> = {}, V = any> extends UseTableCellProps<D, V>, UseGroupByCellProps<D>, UseRowStateCellProps<D> {
+}
+export interface ColumnInterface<D extends Record<string, unknown> = {}> extends UseTableColumnOptions<D>, UseSortByColumnOptions<D>, UseFiltersColumnOptions<D>, UseResizeColumnsColumnOptions<D>, UseGlobalFiltersColumnOptions<D> {
+    /**
+     * Custom class name applied to header column cell.
+     */
+    columnClassName?: string;
+    /**
+     * Custom class name applied to each column's cell.
+     */
+    cellClassName?: string;
+    /**
+     * Type of the data in cell. Used for manual filtering.
+     */
+    fieldType?: FieldType;
+    /**
+     * Filter component used as a column filter. Should use filters from `tableFilters`.
+     */
+    Filter?: Renderer<FilterProps<D>> | Renderer<TableFilterProps<D>>;
+    /**
+     * String value or custom function to use for filtering.
+     * Possible string values: `text`, `exactText`, `exactTextCase`, `includes`, `includesAll`, `exact`, `equals`, `between`.
+     * More info about these filters: https://github.com/tannerlinsley/react-table/blob/master/src/filterTypes.js
+     */
+    filter?: FilterType<D> | DefaultFilterTypes | string;
+    /**
+     * Function that should return whole cell element not only the content.
+     * Must be memoized.
+     * @example
+     * {
+     *   Header: 'Name',
+     *   accessor: 'name',
+     *   cellRenderer: (props) => <EditableCell {...props} onCellEdit={onCellEditHandler} />,
+     * }
+     */
+    cellRenderer?: (props: CellRendererProps<D>) => React.ReactNode;
+    /**
+     * If true, column can't be reordered.
+     * @default false
+     */
+    disableReordering?: boolean;
+    /**
+     * If true, column's visibility cannot be toggled.
+     * @default false
+     */
+    disableToggleVisibility?: boolean;
+    /**
+     * Side on which column should be sticked to.
+     */
+    sticky?: 'left' | 'right';
+}
+export interface ColumnInterfaceBasedOnValue<D extends Record<string, unknown> = {}, V = any> {
+    Cell?: Renderer<CellProps<D, V>> | undefined;
+}
+export interface ColumnGroupInterface<D extends Record<string, unknown>> {
+}
+export type ColumnGroup<D extends Record<string, unknown> = {}> = ColumnInterface<D> & ColumnGroupInterface<D> & ({
+    Header: string;
+} | ({
+    id: IdType<D>;
+} & {
+    Header: Renderer<HeaderProps<D>>;
+})) & {
+    accessor?: Accessor<D> | undefined;
+};
+type ValueOf<T> = T[keyof T];
+export type ColumnWithStrictAccessor<D extends Record<string, unknown> = {}> = ColumnInterface<D> & ValueOf<{
+    [K in keyof D]: {
+        accessor: K;
+    } & ColumnInterfaceBasedOnValue<D, D[K]>;
+}>;
+export type ColumnWithLooseAccessor<D extends Record<string, unknown> = {}> = ColumnInterface<D> & ColumnInterfaceBasedOnValue<D> & ({
+    Header: string;
+} | {
+    id: IdType<D>;
+} | {
+    accessor: keyof D extends never ? IdType<D> : never;
+}) & {
+    accessor?: (keyof D extends never ? IdType<D> | Accessor<D> : Accessor<D>) | undefined;
+};
+export type Column<D extends Record<string, unknown> = {}> = ColumnGroup<D> | ColumnWithLooseAccessor<D> | ColumnWithStrictAccessor<D>;
+export interface ColumnInstance<D extends Record<string, unknown> = {}> extends Omit<ColumnInterface<D>, 'id'>, ColumnInterfaceBasedOnValue<D>, UseTableColumnProps<D>, UseFiltersColumnProps<D>, UseGroupByColumnProps<D>, UseResizeColumnsColumnProps<D>, UseSortByColumnProps<D> {
+    originalWidth: number;
+    resizeWidth?: number;
+    isResizerVisible?: boolean;
+    getDragAndDropProps: () => TableKeyedProps;
+    originalSticky?: 'left' | 'right' | 'none';
+}
+export interface HeaderGroup<D extends Record<string, unknown> = {}> extends ColumnInstance<D>, UseTableHeaderGroupProps<D> {
+}
+export interface Row<D extends Record<string, unknown> = {}> extends UseTableRowProps<D>, UseExpandedRowProps<D>, UseGroupByRowProps<D>, UseRowSelectRowProps<D>, UseRowStateRowProps<D> {
+    initialSubRows: Row<D>[];
+}
+export interface TableCommonProps {
+    style?: CSSProperties | undefined;
+    className?: string | undefined;
+    role?: string | undefined;
+}
+export interface TableProps extends TableCommonProps {
+}
+export interface TableBodyProps extends TableCommonProps {
+}
+export interface TableKeyedProps extends TableCommonProps {
+    key: React.Key;
+}
+export interface TableHeaderGroupProps extends TableKeyedProps {
+}
+export interface TableFooterGroupProps extends TableKeyedProps {
+}
+export interface TableHeaderProps extends TableKeyedProps {
+}
+export interface TableFooterProps extends TableKeyedProps {
+}
+export interface TableRowProps extends TableKeyedProps {
+}
+export interface TableCellProps extends TableKeyedProps {
+}
+export interface TableToggleCommonProps extends TableCommonProps {
+    onChange?: ((e: ChangeEvent) => void) | undefined;
+    checked?: boolean | undefined;
+    title?: string | undefined;
+    indeterminate?: boolean | undefined;
+}
+export interface MetaBase<D extends Record<string, unknown>> {
+    instance: TableInstance<D>;
+    userProps: any;
+}
+export type Meta<D extends Record<string, unknown>, Extension = never, M = MetaBase<D>> = [Extension] extends [never] ? M : M & Extension;
+export declare function useTable<D extends Record<string, unknown> = {}>(options: TableOptions<D>, ...plugins: Array<PluginHook<D>>): TableInstance<D>;
+/**
+ * NOTE: To use custom options, use "Interface Merging" to add the custom options
+ */
+export type UseTableOptions<D extends Record<string, unknown>> = {
+    columns: ReadonlyArray<Column<D>>;
+    data: readonly D[];
+} & Partial<{
+    initialState: Partial<TableState<D>>;
+    stateReducer: (newState: TableState<D>, action: ActionType, previousState: TableState<D>, instance?: TableInstance<D>) => TableState<D>;
+    useControlledState: (state: TableState<D>, meta: Meta<D>) => TableState<D>;
+    defaultColumn: Partial<Column<D>>;
+    getSubRows: (originalRow: D, relativeIndex: number) => D[];
+    getRowId: (originalRow: D, relativeIndex: number, parent?: Row<D>) => string;
+    autoResetHiddenColumns: boolean;
+}>;
+export type PropGetter<D extends Record<string, unknown>, Props, T extends object = never, P = Partial<Props>> = ((props: P, meta: Meta<D, T>) => P | P[]) | P | P[];
+export type TablePropGetter<D extends Record<string, unknown>> = PropGetter<D, TableProps>;
+export type TableBodyPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableBodyProps>;
+export type HeaderPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableHeaderProps, {
+    column: HeaderGroup<D>;
+}>;
+export type FooterGroupPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableFooterGroupProps, {
+    column: HeaderGroup<D>;
+}>;
+export type HeaderGroupPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableHeaderGroupProps, {
+    column: HeaderGroup<D>;
+}>;
+export type FooterPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableFooterProps, {
+    column: HeaderGroup<D>;
+}>;
+export type RowPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableRowProps, {
+    row: Row<D>;
+}>;
+export type CellPropGetter<D extends Record<string, unknown>> = PropGetter<D, TableCellProps, {
+    cell: Cell<D>;
+}>;
+export interface ReducerTableState<D extends Record<string, unknown>> extends TableState<D>, Record<string, any> {
+}
+export interface UseTableHooks<D extends Record<string, unknown>> extends Record<string, any> {
+    useOptions: Array<(options: TableOptions<D>, args: TableOptions<D>) => TableOptions<D>>;
+    stateReducers: Array<(newState: TableState<D>, action: ActionType, previousState?: TableState<D>, instance?: TableInstance<D>) => ReducerTableState<D> | undefined>;
+    columns: Array<(columns: Array<Column<D>>, meta: Meta<D>) => Array<Column<D>>>;
+    columnsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
+    allColumns: Array<(allColumns: Array<ColumnInstance<D>>, meta: Meta<D>) => Array<Column<D>>>;
+    allColumnsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
+    visibleColumns: Array<(allColumns: Array<ColumnInstance<D>>, meta: Meta<D>) => Array<Column<D>>>;
+    visibleColumnsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
+    headerGroups: Array<(allColumns: Array<HeaderGroup<D>>, meta: Meta<D>) => Array<HeaderGroup<D>>>;
+    headerGroupsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
+    useInstanceBeforeDimensions: Array<(instance: TableInstance<D>) => void>;
+    useInstance: Array<(instance: TableInstance<D>) => void>;
+    prepareRow: Array<(row: Row<D>, meta: Meta<D>) => void>;
+    useControlledState: Array<(state: TableState<D>, meta: Meta<D>) => TableState<D>>;
+    getTableProps: Array<TablePropGetter<D>>;
+    getTableBodyProps: Array<TableBodyPropGetter<D>>;
+    getHeaderGroupProps: Array<HeaderGroupPropGetter<D>>;
+    getFooterGroupProps: Array<FooterGroupPropGetter<D>>;
+    getHeaderProps: Array<HeaderPropGetter<D>>;
+    getFooterProps: Array<FooterPropGetter<D>>;
+    getRowProps: Array<RowPropGetter<D>>;
+    getCellProps: Array<CellPropGetter<D>>;
+    useFinalInstance: Array<(instance: TableInstance<D>) => void>;
+}
+export interface UseTableColumnOptions<D extends Record<string, unknown>> {
+    id?: IdType<D> | undefined;
+    Header?: Renderer<HeaderProps<D>> | undefined;
+    Footer?: Renderer<FooterProps<D>> | undefined;
+    width?: number | string | undefined;
+    minWidth?: number | undefined;
+    maxWidth?: number | undefined;
+}
+type UpdateHiddenColumns<D extends Record<string, unknown>> = (oldHidden: Array<IdType<D>>) => Array<IdType<D>>;
+export interface TableToggleHideAllColumnProps extends TableToggleCommonProps {
+}
+export interface UseTableInstanceProps<D extends Record<string, unknown>> {
+    state: TableState<D>;
+    plugins: Array<PluginHook<D>>;
+    dispatch: TableDispatch;
+    columns: Array<ColumnInstance<D>>;
+    allColumns: Array<ColumnInstance<D>>;
+    visibleColumns: Array<ColumnInstance<D>>;
+    headerGroups: Array<HeaderGroup<D>>;
+    footerGroups: Array<HeaderGroup<D>>;
+    headers: Array<ColumnInstance<D>>;
+    flatHeaders: Array<ColumnInstance<D>>;
+    rows: Array<Row<D>>;
+    rowsById: Record<string, Row<D>>;
+    getTableProps: (propGetter?: TablePropGetter<D>) => TableProps;
+    getTableBodyProps: (propGetter?: TableBodyPropGetter<D>) => TableBodyProps;
+    prepareRow: (row: Row<D>) => void;
+    flatRows: Array<Row<D>>;
+    totalColumnsWidth: number;
+    allColumnsHidden: boolean;
+    toggleHideColumn: (columnId: IdType<D>, value?: boolean) => void;
+    setHiddenColumns: (param: Array<IdType<D>> | UpdateHiddenColumns<D>) => void;
+    toggleHideAllColumns: (value?: boolean) => void;
+    getToggleHideAllColumnsProps: (props?: Partial<TableToggleHideAllColumnProps>) => TableToggleHideAllColumnProps;
+    getHooks: () => Hooks<D>;
+}
+export interface UseTableHeaderGroupProps<D extends Record<string, unknown>> {
+    headers: Array<HeaderGroup<D>>;
+    getHeaderGroupProps: (propGetter?: HeaderGroupPropGetter<D>) => TableHeaderProps;
+    getFooterGroupProps: (propGetter?: FooterGroupPropGetter<D>) => TableFooterProps;
+    totalHeaderCount: number;
+}
+export interface UseTableColumnProps<D extends Record<string, unknown>> {
+    id: IdType<D>;
+    columns?: Array<ColumnInstance<D>> | undefined;
+    isVisible: boolean;
+    render: (type: 'Header' | 'Footer' | string, props?: object) => ReactNode;
+    totalLeft: number;
+    totalWidth: number;
+    getHeaderProps: (propGetter?: HeaderPropGetter<D>) => TableHeaderProps;
+    getFooterProps: (propGetter?: FooterPropGetter<D>) => TableFooterProps;
+    toggleHidden: (value?: boolean) => void;
+    parent?: ColumnInstance<D> | undefined;
+    getToggleHiddenProps: (userProps?: any) => any;
+    depth: number;
+    placeholderOf?: ColumnInstance | undefined;
+}
+export interface UseTableRowProps<D extends Record<string, unknown>> {
+    cells: Array<Cell<D>>;
+    allCells: Array<Cell<D>>;
+    values: Record<IdType<D>, CellValue>;
+    getRowProps: (propGetter?: RowPropGetter<D>) => TableRowProps;
+    index: number;
+    original: D;
+    id: string;
+    subRows: Array<Row<D>>;
+}
+export interface UseTableCellProps<D extends Record<string, unknown>, V = any> {
+    column: ColumnInstance<D>;
+    row: Row<D>;
+    value: CellValue<V>;
+    getCellProps: (propGetter?: CellPropGetter<D>) => TableCellProps;
+    render: (type: 'Cell' | string, userProps?: object) => ReactNode;
+}
+export type HeaderProps<D extends Record<string, unknown>> = TableInstance<D> & {
+    column: ColumnInstance<D>;
+};
+export type FooterProps<D extends Record<string, unknown>> = TableInstance<D> & {
+    column: ColumnInstance<D>;
+};
+export type CellProps<D extends Record<string, unknown>, V = any> = TableInstance<D> & {
+    column: ColumnInstance<D>;
+    row: Row<D>;
+    cell: Cell<D, V>;
+    value: CellValue<V>;
+};
+export type Accessor<D extends Record<string, unknown>> = (originalRow: D, index: number, sub: {
+    subRows: D[];
+    depth: number;
+    data: D[];
+}) => CellValue;
+export declare function useAbsoluteLayout<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export declare function useBlockLayout<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export declare function useColumnOrder<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export interface UseColumnOrderState<D extends Record<string, unknown>> {
+    columnOrder: Array<IdType<D>>;
+}
+export interface UseColumnOrderInstanceProps<D extends Record<string, unknown>> {
+    setColumnOrder: (updater: ((columnOrder: Array<IdType<D>>) => Array<IdType<D>>) | Array<IdType<D>>) => void;
+}
+export declare function useExpanded<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export interface TableExpandedToggleProps extends TableKeyedProps {
+}
+export type UseExpandedOptions<D extends Record<string, unknown>> = Partial<{
+    manualExpandedKey: IdType<D>;
+    paginateExpandedRows: boolean;
+    expandSubRows: boolean;
+    autoResetExpanded?: boolean | undefined;
+}>;
+export interface UseExpandedHooks<D extends Record<string, unknown>> {
+    getToggleRowsExpandedProps: Array<PropGetter<D, TableCommonProps>>;
+    getToggleAllRowsExpandedProps: Array<PropGetter<D, TableCommonProps>>;
+}
+export interface UseExpandedState<D extends Record<string, unknown>> {
+    expanded: Record<IdType<D>, boolean>;
+}
+export interface UseExpandedInstanceProps<D extends Record<string, unknown>> {
+    preExpandedRows: Array<Row<D>>;
+    expandedRows: Array<Row<D>>;
+    rows: Array<Row<D>>;
+    expandedDepth: number;
+    isAllRowsExpanded: boolean;
+    toggleRowExpanded: (id: Array<IdType<D>>, value?: boolean) => void;
+    toggleAllRowsExpanded: (value?: boolean) => void;
+}
+export interface UseExpandedRowProps<D extends Record<string, unknown>> {
+    isExpanded: boolean;
+    canExpand: boolean;
+    subRows: Array<Row<D>>;
+    toggleRowExpanded: (value?: boolean) => void;
+    getToggleRowExpandedProps: (props?: Partial<TableExpandedToggleProps>) => TableExpandedToggleProps;
+    depth: number;
+}
+export declare function useFilters<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export type UseFiltersOptions<D extends Record<string, unknown>> = Partial<{
+    manualFilters: boolean;
+    disableFilters: boolean;
+    defaultCanFilter: boolean;
+    filterTypes: FilterTypes<D>;
+    autoResetFilters?: boolean | undefined;
+}>;
+export interface UseFiltersState<D extends Record<string, unknown>> {
+    filters: Filters<D>;
+}
+export type UseFiltersColumnOptions<D extends Record<string, unknown>> = Partial<{
+    Filter: Renderer<FilterProps<D>>;
+    disableFilters: boolean;
+    defaultCanFilter: boolean;
+    filter: FilterType<D> | DefaultFilterTypes | string;
+}>;
+export interface UseFiltersInstanceProps<D extends Record<string, unknown>> {
+    preFilteredRows: Array<Row<D>>;
+    preFilteredFlatRows: Array<Row<D>>;
+    preFilteredRowsById: Record<string, Row<D>>;
+    filteredRows: Array<Row<D>>;
+    filteredFlatRows: Array<Row<D>>;
+    filteredRowsById: Record<string, Row<D>>;
+    rows: Array<Row<D>>;
+    flatRows: Array<Row<D>>;
+    rowsById: Record<string, Row<D>>;
+    setFilter: (columnId: IdType<D>, updater: ((filterValue: FilterValue) => FilterValue) | FilterValue) => void;
+    setAllFilters: (updater: Filters<D> | ((filters: Filters<D>) => Filters<D>)) => void;
+}
+export interface UseFiltersColumnProps<D extends Record<string, unknown>> {
+    canFilter: boolean;
+    setFilter: (updater: ((filterValue: FilterValue) => FilterValue) | FilterValue) => void;
+    filterValue: FilterValue;
+    preFilteredRows: Array<Row<D>>;
+    filteredRows: Array<Row<D>>;
+}
+export type FilterProps<D extends Record<string, unknown>> = HeaderProps<D>;
+export type FilterValue = any;
+export type Filters<D extends Record<string, unknown>> = Array<{
+    id: IdType<D>;
+    value: FilterValue;
+}>;
+export type FilterTypes<D extends Record<string, unknown>> = Record<string, FilterType<D>>;
+export type DefaultFilterTypes = 'text' | 'exactText' | 'exactTextCase' | 'includes' | 'includesAll' | 'exact' | 'equals' | 'between';
+export interface FilterType<D extends Record<string, unknown>> {
+    (rows: Array<Row<D>>, columnIds: Array<IdType<D>>, filterValue: FilterValue): Array<Row<D>>;
+    autoRemove?: ((filterValue: FilterValue) => boolean) | undefined;
+}
+export declare function useFlexLayout<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export declare function useGridLayout<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export declare function useGlobalFilter<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export type UseGlobalFiltersOptions<D extends Record<string, unknown>> = Partial<{
+    globalFilter: ((rows: Array<Row<D>>, columnIds: Array<IdType<D>>, filterValue: any) => Array<Row<D>>) | string;
+    manualGlobalFilter: boolean;
+    filterTypes: FilterTypes<D>;
+    autoResetGlobalFilter?: boolean | undefined;
+    disableGlobalFilter?: boolean | undefined;
+}>;
+export interface UseGlobalFiltersState<D extends Record<string, unknown>> {
+    globalFilter: any;
+}
+export type UseGlobalFiltersColumnOptions<D extends Record<string, unknown>> = Partial<{
+    disableGlobalFilter?: boolean | undefined;
+}>;
+export interface UseGlobalFiltersInstanceProps<D extends Record<string, unknown>> {
+    preGlobalFilteredRows: Array<Row<D>>;
+    preGlobalFilteredFlatRows: Array<Row<D>>;
+    preGlobalFilteredRowsById: Record<string, Row<D>>;
+    globalFilteredRows: Array<Row<D>>;
+    globalFilteredFlatRows: Array<Row<D>>;
+    globalFilteredRowsById: Record<string, Row<D>>;
+    rows: Array<Row<D>>;
+    flatRows: Array<Row<D>>;
+    rowsById: Record<string, Row<D>>;
+    setGlobalFilter: (filterValue: FilterValue) => void;
+}
+export declare function useGroupBy<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export interface TableGroupByToggleProps {
+    title?: string | undefined;
+    style?: CSSProperties | undefined;
+    onClick?: ((e: MouseEvent) => void) | undefined;
+}
+export type UseGroupByOptions<D extends Record<string, unknown>> = Partial<{
+    manualGroupBy: boolean;
+    disableGroupBy: boolean;
+    defaultCanGroupBy: boolean;
+    aggregations: Record<string, AggregatorFn<D>>;
+    groupByFn: (rows: Array<Row<D>>, columnId: IdType<D>) => Record<string, Array<Row<D>>>;
+    autoResetGroupBy?: boolean | undefined;
+}>;
+export interface UseGroupByHooks<D extends Record<string, unknown>> {
+    getGroupByToggleProps: Array<HeaderGroupPropGetter<D>>;
+}
+export interface UseGroupByState<D extends Record<string, unknown>> {
+    groupBy: Array<IdType<D>>;
+}
+export type UseGroupByColumnOptions<D extends Record<string, unknown>> = Partial<{
+    aggregate: Aggregator<D>;
+    Aggregated: Renderer<CellProps<D>>;
+    disableGroupBy: boolean;
+    defaultCanGroupBy: boolean;
+}>;
+export interface UseGroupByInstanceProps<D extends Record<string, unknown>> {
+    preGroupedRows: Array<Row<D>>;
+    preGroupedFlatRows: Array<Row<D>>;
+    preGroupedRowsById: Record<string, Row<D>>;
+    groupedRows: Array<Row<D>>;
+    groupedFlatRows: Array<Row<D>>;
+    groupedRowsById: Record<string, Row<D>>;
+    onlyGroupedFlatRows: Array<Row<D>>;
+    onlyGroupedRowsById: Record<string, Row<D>>;
+    nonGroupedFlatRows: Array<Row<D>>;
+    nonGroupedRowsById: Record<string, Row<D>>;
+    rows: Array<Row<D>>;
+    flatRows: Array<Row<D>>;
+    rowsById: Record<string, Row<D>>;
+    toggleGroupBy: (columnId: IdType<D>, value?: boolean) => void;
+}
+export interface UseGroupByColumnProps<D extends Record<string, unknown>> {
+    canGroupBy: boolean;
+    isGrouped: boolean;
+    groupedIndex: number;
+    toggleGroupBy: () => void;
+    getGroupByToggleProps: (props?: Partial<TableGroupByToggleProps>) => TableGroupByToggleProps;
+}
+export interface UseGroupByRowProps<D extends Record<string, unknown>> {
+    isGrouped: boolean;
+    groupByID: IdType<D>;
+    groupByVal: string;
+    values: Record<IdType<D>, AggregatedValue>;
+    subRows: Array<Row<D>>;
+    leafRows: Array<Row<D>>;
+    depth: number;
+    id: string;
+    index: number;
+}
+export interface UseGroupByCellProps<D extends Record<string, unknown>> {
+    isGrouped: boolean;
+    isPlaceholder: boolean;
+    isAggregated: boolean;
+}
+export type DefaultAggregators = 'sum' | 'average' | 'median' | 'uniqueCount' | 'count';
+export type AggregatorFn<D extends Record<string, unknown>> = (columnValues: CellValue[], rows: Array<Row<D>>, isAggregated: boolean) => AggregatedValue;
+export type Aggregator<D extends Record<string, unknown>> = AggregatorFn<D> | DefaultAggregators | string;
+export type AggregatedValue = any;
+export declare function usePagination<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export type UsePaginationOptions<D extends Record<string, unknown>> = Partial<{
+    pageCount: number;
+    manualPagination: boolean;
+    autoResetPage?: boolean | undefined;
+    paginateExpandedRows: boolean;
+}>;
+export interface UsePaginationState<D extends Record<string, unknown>> {
+    pageSize: number;
+    pageIndex: number;
+}
+export interface UsePaginationInstanceProps<D extends Record<string, unknown>> {
+    page: Array<Row<D>>;
+    pageCount: number;
+    pageOptions: number[];
+    canPreviousPage: boolean;
+    canNextPage: boolean;
+    gotoPage: (updater: ((pageIndex: number) => number) | number) => void;
+    previousPage: () => void;
+    nextPage: () => void;
+    setPageSize: (pageSize: number) => void;
+}
+export declare function useResizeColumns<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export interface UseResizeColumnsOptions<D extends Record<string, unknown>> {
+    disableResizing?: boolean | undefined;
+    autoResetResize?: boolean | undefined;
+}
+export interface UseResizeColumnsState<D extends Record<string, unknown>> {
+    columnResizing: {
+        startX?: number | undefined;
+        columnWidth: number;
+        headerIdWidths: Record<string, number>;
+        columnWidths: any;
+        isResizingColumn?: string | undefined;
+    };
+}
+export interface UseResizeColumnsColumnOptions<D extends Record<string, unknown>> {
+    disableResizing?: boolean | undefined;
+}
+export interface TableResizerProps {
+}
+export interface UseResizeColumnsColumnProps<D extends Record<string, unknown>> {
+    getResizerProps: (props?: Partial<TableResizerProps>) => TableResizerProps;
+    canResize: boolean;
+    isResizing: boolean;
+}
+export declare function useRowSelect<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export interface TableToggleAllRowsSelectedProps extends TableToggleCommonProps {
+}
+export interface TableToggleRowsSelectedProps extends TableToggleCommonProps {
+}
+export type UseRowSelectOptions<D extends Record<string, unknown>> = Partial<{
+    manualRowSelectedKey: IdType<D>;
+    autoResetSelectedRows: boolean;
+    selectSubRows: boolean;
+}>;
+export interface UseRowSelectHooks<D extends Record<string, unknown>> {
+    getToggleRowSelectedProps: Array<PropGetter<D, TableToggleRowsSelectedProps>>;
+    getToggleAllRowsSelectedProps: Array<PropGetter<D, TableToggleAllRowsSelectedProps>>;
+    getToggleAllPageRowsSelectedProps: Array<PropGetter<D, TableToggleAllRowsSelectedProps>>;
+}
+export interface UseRowSelectState<D extends Record<string, unknown>> {
+    selectedRowIds: Record<IdType<D>, boolean>;
+}
+export interface UseRowSelectInstanceProps<D extends Record<string, unknown>> {
+    toggleRowSelected: (rowId: IdType<D>, set?: boolean) => void;
+    toggleAllRowsSelected: (value?: boolean) => void;
+    getToggleAllRowsSelectedProps: (props?: Partial<TableToggleAllRowsSelectedProps>) => TableToggleAllRowsSelectedProps;
+    getToggleAllPageRowsSelectedProps: (props?: Partial<TableToggleAllRowsSelectedProps>) => TableToggleAllRowsSelectedProps;
+    isAllRowsSelected: boolean;
+    selectedFlatRows: Array<Row<D>>;
+}
+export interface UseRowSelectRowProps<D extends Record<string, unknown>> {
+    isSelected: boolean;
+    isSomeSelected: boolean;
+    toggleRowSelected: (set?: boolean) => void;
+    getToggleRowSelectedProps: (props?: Partial<TableToggleRowsSelectedProps>) => TableToggleRowsSelectedProps;
+}
+export declare function useRowState<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export type UseRowStateOptions<D extends Record<string, unknown>> = Partial<{
+    initialRowStateAccessor: (row: Row<D>) => UseRowStateLocalState<D>;
+    getResetRowStateDeps: (instance: TableInstance<D>) => any[];
+    autoResetRowState?: boolean | undefined;
+}>;
+export interface UseRowStateState<D extends Record<string, unknown>> {
+    rowState: Record<string, {
+        cellState: UseRowStateLocalState<D>;
+    }>;
+}
+export interface UseRowStateInstanceProps<D extends Record<string, unknown>> {
+    setRowState: (rowPath: string[], updater: UseRowUpdater) => void;
+    setCellState: (rowPath: string[], columnId: IdType<D>, updater: UseRowUpdater) => void;
+}
+export interface UseRowStateRowProps<D extends Record<string, unknown>> {
+    state: UseRowStateLocalState<D>;
+    setState: (updater: UseRowUpdater) => void;
+}
+export interface UseRowStateCellProps<D extends Record<string, unknown>> {
+    state: UseRowStateLocalState<D>;
+    setState: (updater: UseRowUpdater) => void;
+}
+export type UseRowUpdater<T = unknown> = T | ((prev: T) => T);
+export type UseRowStateLocalState<D extends Record<string, unknown>, T = unknown> = Record<IdType<D>, T>;
+export declare function useSortBy<D extends Record<string, unknown> = {}>(hooks: Hooks<D>): void;
+export interface TableSortByToggleProps {
+    title?: string | undefined;
+    style?: CSSProperties | undefined;
+    onClick?: ((e: MouseEvent) => void) | undefined;
+}
+export type UseSortByOptions<D extends Record<string, unknown>> = Partial<{
+    manualSortBy: boolean;
+    disableSortBy: boolean;
+    defaultCanSort: boolean;
+    disableMultiSort: boolean;
+    isMultiSortEvent: (e: MouseEvent) => boolean;
+    maxMultiSortColCount: number;
+    disableSortRemove: boolean;
+    disabledMultiRemove: boolean;
+    orderByFn: (rows: Array<Row<D>>, sortFns: Array<OrderByFn<D>>, directions: boolean[]) => Array<Row<D>>;
+    sortTypes: Record<string, SortByFn<D>>;
+    autoResetSortBy?: boolean | undefined;
+}>;
+export interface UseSortByHooks<D extends Record<string, unknown>> {
+    getSortByToggleProps: Array<PropGetter<D, TableCommonProps>>;
+}
+export interface UseSortByState<D extends Record<string, unknown>> {
+    sortBy: Array<SortingRule<D>>;
+}
+export type UseSortByColumnOptions<D extends Record<string, unknown>> = Partial<{
+    defaultCanSort: boolean;
+    disableSortBy: boolean;
+    sortDescFirst: boolean;
+    sortInverted: boolean;
+    sortType: SortByFn<D> | DefaultSortTypes | string;
+}>;
+export interface UseSortByInstanceProps<D extends Record<string, unknown>> {
+    rows: Array<Row<D>>;
+    preSortedRows: Array<Row<D>>;
+    setSortBy: (sortBy: Array<SortingRule<D>>) => void;
+    toggleSortBy: (columnId: IdType<D>, descending?: boolean, isMulti?: boolean) => void;
+}
+export interface UseSortByColumnProps<D extends Record<string, unknown>> {
+    canSort: boolean;
+    toggleSortBy: (descending?: boolean, multi?: boolean) => void;
+    getSortByToggleProps: (props?: Partial<TableSortByToggleProps>) => TableSortByToggleProps;
+    clearSortBy: () => void;
+    isSorted: boolean;
+    sortedIndex: number;
+    isSortedDesc: boolean | undefined;
+}
+export type OrderByFn<D extends Record<string, unknown>> = (rowA: Row<D>, rowB: Row<D>) => number;
+export type SortByFn<D extends Record<string, unknown>> = (rowA: Row<D>, rowB: Row<D>, columnId: IdType<D>, desc?: boolean) => number;
+export type DefaultSortTypes = 'alphanumeric' | 'datetime' | 'basic' | 'string' | 'number';
+export interface SortingRule<D> {
+    id: IdType<D>;
+    desc?: boolean | undefined;
+}
+export declare const actions: Record<string, string>;
+export type ActionType = {
+    type: string;
+} & Record<string, any>;
+export declare const defaultColumn: Partial<Column> & Record<string, any>;
+export type StringKey<D> = Extract<keyof D, string>;
+export type IdType<D> = StringKey<D> | string;
+export type CellValue<V = any> = V;
+export type Renderer<Props> = ComponentType<Props> | ReactElement | string | number | ReactFragment;
+export interface PluginHook<D extends Record<string, unknown>> {
+    (hooks: Hooks<D>): void;
+    pluginName?: string | undefined;
+}
+export type TableDispatch<A = any> = (action: A) => void;
+export declare function defaultOrderByFn<D extends Record<string, unknown> = {}>(arr: Array<Row<D>>, funcs: Array<OrderByFn<D>>, dirs: boolean[]): Array<Row<D>>;
+export declare function defaultGroupByFn<D extends Record<string, unknown> = {}>(rows: Array<Row<D>>, columnId: IdType<D>): Record<string, Array<Row<D>>>;
+export declare function makePropGetter(hooks: Hooks, ...meta: any[]): any;
+export declare function reduceHooks<T extends object = {}>(hooks: Hooks, initial: T, ...args: any[]): T;
+export declare function loopHooks(hooks: Hooks, ...args: any[]): void;
+export declare function ensurePluginOrder<D extends Record<string, unknown> = {}>(plugins: Array<PluginHook<D>>, befores: string[], pluginName: string): void;
+export declare function functionalUpdate<D extends Record<string, unknown> = {}>(updater: any, old: Partial<TableState<D>>): Partial<TableState<D>>;
+export declare function useGetLatest<T>(obj: T): () => T;
+export declare function safeUseLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
+export declare function useMountedLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
+export declare function useAsyncDebounce<F extends (...args: any[]) => any>(defaultFn: F, defaultWait?: number): F;
+export declare function makeRenderer(instance: TableInstance, column: ColumnInstance, meta?: any): ReactElement;
+export {};