@infinite-table/infinite-react 0.3.22 → 0.4.2

package/index.d.ts

@@ -1,14 +1,39 @@
 import * as React$1 from 'react';
-import { RefCallback, MutableRefObject, CSSProperties, HTMLProps } from 'react';
+import { CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, KeyboardEvent } from 'react';
 
-declare function debounce(fn: Function, { wait }: {
-    wait: number;
-}): (...args: any[]) => void;
+declare type SortDir = 1 | -1;
+declare type MultisortInfo<T> = {
+    /**
+     * The sorting direction
+     */
+    dir: SortDir;
+    /**
+     * for now 'string' and 'number' are known types, meaning they have
+     * sort functions already implemented
+     */
+    type?: string;
+    fn?: (a: any, b: any) => number;
+    /**
+     * a property whose value to use for sorting on the array items
+     */
+    field?: keyof T;
+    /**
+     * or a function to retrieve the item value to use for sorting
+     */
+    valueGetter?: (item: T) => any;
+};
+declare const multisort: {
+    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
+};
 
 declare type VoidFn$1 = () => void;
 declare type Pair<KeyType, ValueType> = {
     value?: ValueType;
     map?: Map<KeyType, Pair<KeyType, ValueType>>;
+    length: number;
     revision?: number;
 };
 declare type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn$1) => void;
@@ -19,9 +44,12 @@ declare class DeepMap<KeyType, ValueType> {
     private emptyKey;
     static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
     constructor(initial?: [KeyType[], ValueType][]);
-    getValuesStartingWith(keys: KeyType[]): ValueType[];
-    getKeysStartingWith(keys: KeyType[]): KeyType[][];
+    fill(initial?: [KeyType[], ValueType][]): void;
+    getValuesStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): ValueType[];
+    getKeysStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): KeyType[][];
     private getStartingWith;
+    private getMapAt;
+    getAllChildrenSizeFor(keys: KeyType[]): number;
     getDirectChildrenSizeFor(keys: KeyType[]): number;
     set(keys: KeyType[] & {
         length: Omit<number, 0>;
@@ -36,6 +64,7 @@ declare class DeepMap<KeyType, ValueType> {
     visitDepthFirst: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn$1 | undefined) => void) => void;
     private visitWithNext;
     private getArray;
+    valuesAt(keys: KeyType[]): ValueType[];
     values(): Generator<ValueType, void, unknown>;
     keys(): Generator<KeyType[], void, unknown>;
     entries(): Generator<[KeyType[], ValueType], void, unknown>;
@@ -45,34 +74,27 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
-declare class GroupRowsState<KeyType extends any = any> {
-    private expandedMap?;
-    private collapsedMap?;
-    private collapsedAll;
-    private expandedAll;
-    private initialState;
-    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
-    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
-    destroy(): void;
-    private update;
-    areAllCollapsed(): boolean;
-    areAllExpanded(): boolean;
-    collapseAll(): void;
-    expandAll(): void;
-    isGroupRowExpanded(keys: KeyType[]): boolean | undefined;
-    isGroupRowCollapsed(keys: KeyType[]): boolean;
-    setGroupRowExpanded(keys: KeyType[], shouldExpand: boolean): void;
-    collapseGroupRow(keys: KeyType[]): void;
-    expandGroupRow(keys: KeyType[]): void;
-    toggleGroupRow(keys: KeyType[]): void;
-}
-
-declare type Renderable = React$1.ReactNode | JSX.Element;
-
-interface Size {
-    width: number;
-    height: number;
-}
+declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
+    getComponentState: () => T_STATE;
+    componentState: T_STATE;
+    componentActions: T_ACTIONS;
+};
+declare type ComponentStateGeneratedActions<T_STATE> = {
+    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
+};
+declare type ComponentInterceptedActions<T_STATE> = {
+    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
+        actions: ComponentStateGeneratedActions<T_STATE>;
+        state: T_STATE;
+    }) => void | boolean;
+};
+declare type ComponentMappedCallbacks<T_STATE> = {
+    [k in keyof T_STATE]: (value: T_STATE[k], state: T_STATE) => {
+        callbackName: string;
+        callbackParams: any[];
+    };
+};
+declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
 
 declare enum InfiniteTableActionType {
     SET_COLUMN_SIZE = 0,
@@ -91,69 +113,316 @@ declare type InfiniteTableAction = {
     payload?: any;
 };
 
-interface LogFn {
-    (...args: any[]): LogFn;
-    extend: (channelName: string) => LogFn;
-}
-declare class Logger {
-    debug: LogFn;
-    error: LogFn;
-    constructor(channelName: string);
+declare type Renderable = React$1.ReactNode | JSX.Element;
+
+declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParam<T, InfiniteTableComputedColumn<T>>;
+
+declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
+
+declare const InfiniteTableClassName: string;
+declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => JSX.Element)>;
+declare function InfiniteTable<T>(props: InfiniteTableProps<T>): JSX.Element;
+declare namespace InfiniteTable {
+    var defaultProps: {
+        rowHeight: number;
+        columnHeaderHeight: string;
+    };
 }
 
-interface ScrollPosition {
-    scrollTop: number;
-    scrollLeft: number;
+interface Size {
+    width: number;
+    height: number;
 }
-declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
 
-declare type VoidFn = () => void;
+declare type InfiniteTableBaseCellProps<T> = {
+    column: InfiniteTableComputedColumn<T>;
+    renderChildren: () => Renderable;
+    width: number;
+    cssEllipsis?: boolean;
+    contentStyle?: CSSProperties;
+    contentClassName?: string;
+    virtualized?: boolean;
+    skipColumnShifting?: boolean;
+    beforeChildren?: Renderable;
+    afterChildren?: Renderable;
+    cssPosition?: CSSProperties['position'];
+    domRef?: React.RefCallback<HTMLElement>;
+};
+declare type InfiniteTableCellProps<T> = ({
+    cellType: 'header';
+} & InfiniteTableBaseCellProps<T>) | ({
+    cellType: 'body';
+} & InfiniteTableBaseCellProps<T>);
 
-declare type FixedPosition = false | 'start' | 'end';
-declare type SpanFunction = ({ rowIndex, colIndex, }: {
+declare type DiscriminatedUnion<A, B> = (A & {
+    [K in keyof B]?: undefined;
+}) | (B & {
+    [K in keyof A]?: undefined;
+});
+
+declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
+declare type InfiniteTableSelectRowFn = (id: any) => void;
+declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    dragging: boolean;
+    column: COL_TYPE;
+    columnsMap: Map<string, COL_TYPE>;
+    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
+    columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
+    selectionMode: DataSourcePropSelectionMode;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    api: InfiniteTableApi<DATA_TYPE>;
+    renderBag: {
+        header: string | number | Renderable;
+        sortIcon?: Renderable;
+        selectionCheckBox?: Renderable;
+    };
+};
+declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    value: string | number | Renderable;
+    renderBag: {
+        value: string | number | Renderable;
+        groupIcon?: Renderable;
+        selectionCheckBox?: Renderable;
+    };
+    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
     rowIndex: number;
-    colIndex: number;
-}) => number;
-declare type RenderRangeType = {
-    startIndex: number;
-    endIndex: number;
+    rowActive: boolean;
+    column: COL_TYPE;
+    columnsMap: Map<string, COL_TYPE>;
+    toggleCurrentGroupRow: () => void;
+    toggleGroupRow: InfiniteTableToggleGroupRowFn;
+    toggleCurrentGroupRowSelection: () => void;
+    selectCurrentRow: () => void;
+    selectRow: InfiniteTableSelectRowFn;
+    deselectRow: InfiniteTableSelectRowFn;
+    deselectCurrentRow: () => void;
+    toggleRowSelection: InfiniteTableSelectRowFn;
+    selectionMode: DataSourcePropSelectionMode | undefined;
+    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
+    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
 };
-declare type ItemSizeFunction = (index: number) => number;
-declare type MatrixBrainOptions = {
-    width: number;
-    height: number;
-    cols: number;
-    rows: number;
-    rowHeight: number | ItemSizeFunction;
-    colWidth: number | ItemSizeFunction;
-    rowspan?: SpanFunction;
-    colspan?: SpanFunction;
+declare type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
+declare type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParam<DATA_TYPE> & {};
+declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
+declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
+    data: DATA_TYPE | Partial<DATA_TYPE> | null;
+    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
+    rowIndex: number;
+    column: COL_TYPE;
 };
-declare type TableRenderRange = {
-    start: [number, number];
-    end: [number, number];
-    rowFixed?: FixedPosition;
-    colFixed?: FixedPosition;
+declare type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE> & {
+    isGroupRow: true;
+}) => Renderable | null;
+declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
+declare type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
+declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
+declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
+declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
+declare type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
+declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
+declare type InfiniteTableColumnStyleFnParams<T> = {
+    value: Renderable;
+    column: InfiniteTableComputedColumn<T>;
+} & InfiniteTableRowInfoDataDiscriminator<T>;
+declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
+declare type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
+declare type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React.CSSProperties;
+declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
+declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
+declare type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
+declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
+declare type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
+declare type InfiniteTableColumnValueGetterParams<T> = {
+    data: T;
+    field?: keyof T;
 };
-declare type WhichDirection = {
-    horizontal?: boolean;
-    vertical?: boolean;
+declare type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
+declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
+declare type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
+declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
+declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
+declare type InfiniteTableBaseColumn<T> = {
+    sortable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    comparer?: InfiniteTableColumnComparer<T>;
+    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
+        [k in keyof Partial<T>]: true;
+    };
+    align?: InfiniteTableColumnAlign;
+    verticalAlign?: InfiniteTableColumnVerticalAlign;
+    columnGroup?: string;
+    header?: InfiniteTableColumnHeader<T>;
+    renderHeader?: InfiniteTableColumnHeaderRenderFunction<T>;
+    name?: Renderable;
+    cssEllipsis?: boolean;
+    headerCssEllipsis?: boolean;
+    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
+    dataType?: InfiniteTableDataTypeNames;
+    sortType?: string;
+    filterType?: string;
+    style?: InfiniteTableColumnStyle<T>;
+    headerStyle?: InfiniteTableColumnHeaderStyle<T>;
+    headerClassName?: InfiniteTableColumnHeaderClassName<T>;
+    className?: InfiniteTableColumnClassName<T>;
+    rowspan?: InfiniteTableColumnRowspanFn<T>;
+    field?: keyof T;
+    render?: InfiniteTableColumnRenderFunction<T>;
+    renderValue?: InfiniteTableColumnRenderFunction<T>;
+    renderGroupValue?: InfiniteTableColumnRenderFunction<T>;
+    renderLeafValue?: InfiniteTableColumnRenderFunction<T>;
+    valueGetter?: InfiniteTableColumnValueGetter<T>;
+    valueFormatter?: InfiniteTableColumnValueFormatter<T>;
+    defaultWidth?: number;
+    defaultFlex?: number;
+    defaultFilterable?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<T>;
+    renderSortIcon?: InfiniteTableColumnHeaderRenderFunction<T>;
+    renderSelectionCheckBox?: boolean | InfiniteTableColumnRenderFunction<T>;
+    renderHeaderSelectionCheckBox?: boolean | InfiniteTableColumnHeaderRenderFunction<T>;
+    components?: {
+        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+    };
 };
-declare type FnOnRenderRangeChange = (range: TableRenderRange) => void;
-declare type FnOnDirectionalRenderRangeChange = (range: [number, number]) => void;
-declare type FnOnRenderCountChange = ({ horizontal, vertical, }: {
-    horizontal: number;
-    vertical: number;
-}) => void;
-declare type OnAvailableSizeChange = (size: Size) => void;
-declare class MatrixBrain extends Logger {
-    private scrolling;
-    private width;
-    private height;
-    private cols;
-    private rows;
-    private rowHeight;
-    private colWidth;
+/**
+ * Defines a column in the table.
+ *
+ * @typeParam DATA_TYPE The type of the data in the table.
+ *
+ * Can be bound to a field which is a `keyof DATA_TYPE`.
+ */
+declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE>;
+declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
+    groupByField: string | string[];
+    id?: string;
+};
+declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
+declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotTotalColumnGroup?: true;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex: PivotBy<DataType, KeyType>;
+    pivotGroupKey: KeyType;
+    pivotIndex: number;
+};
+declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotColumn: true;
+    pivotTotalColumn: boolean;
+    pivotAggregator: AggregationReducer<DataType, any>;
+    pivotAggregatorIndex: number;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex?: PivotBy<DataType, KeyType>;
+    pivotIndex: number;
+    pivotGroupKey: KeyType;
+};
+declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
+declare type InfiniteTableComputedColumnBase<T> = {
+    computedFilterType: string;
+    computedSortType: string;
+    computedDataType: string;
+    computedWidth: number;
+    computedFlex: number | null;
+    computedMinWidth: number;
+    computedMaxWidth: number;
+    computedOffset: number;
+    computedPinningOffset: number;
+    computedAbsoluteOffset: number;
+    computedSortable: boolean;
+    computedSortInfo: DataSourceSingleSortInfo<T> | null;
+    computedSorted: boolean;
+    computedSortedAsc: boolean;
+    computedSortedDesc: boolean;
+    computedSortIndex: number;
+    computedVisibleIndex: number;
+    computedVisibleIndexInCategory: number;
+    computedMultiSort: boolean;
+    computedFiltered: boolean;
+    computedFilterable: boolean;
+    computedFilterValue: DataSourceFilterValueItem<T> | null;
+    computedPinned: InfiniteTableColumnPinnedValues;
+    computedDraggable: boolean;
+    computedResizable: boolean;
+    computedFirstInCategory: boolean;
+    computedLastInCategory: boolean;
+    computedFirst: boolean;
+    computedLast: boolean;
+    toggleSort: () => void;
+    id: string;
+};
+declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
+declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
+
+interface LogFn {
+    (...args: any[]): LogFn;
+    extend: (channelName: string) => LogFn;
+}
+declare class Logger {
+    debug: LogFn;
+    error: LogFn;
+    constructor(channelName: string);
+}
+
+interface ScrollPosition {
+    scrollTop: number;
+    scrollLeft: number;
+}
+declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
+
+declare type VoidFn = () => void;
+
+declare type FixedPosition = false | 'start' | 'end';
+declare type SpanFunction = ({ rowIndex, colIndex, }: {
+    rowIndex: number;
+    colIndex: number;
+}) => number;
+declare type RenderRangeType = {
+    startIndex: number;
+    endIndex: number;
+};
+declare type ItemSizeFunction = (index: number) => number;
+declare type MatrixBrainOptions = {
+    width: number;
+    height: number;
+    cols: number;
+    rows: number;
+    rowHeight: number | ItemSizeFunction;
+    colWidth: number | ItemSizeFunction;
+    rowspan?: SpanFunction;
+    colspan?: SpanFunction;
+};
+declare type TableRenderRange = {
+    start: [number, number];
+    end: [number, number];
+    rowFixed?: FixedPosition;
+    colFixed?: FixedPosition;
+};
+declare type WhichDirection = {
+    horizontal?: boolean;
+    vertical?: boolean;
+};
+declare type FnOnRenderRangeChange = (range: TableRenderRange) => void;
+declare type FnOnDirectionalRenderRangeChange = (range: [number, number]) => void;
+declare type FnOnRenderCountChange = ({ horizontal, vertical, }: {
+    horizontal: number;
+    vertical: number;
+}) => void;
+declare type OnAvailableSizeChange = (size: Size) => void;
+declare class MatrixBrain extends Logger {
+    private scrolling;
+    private width;
+    private height;
+    private cols;
+    private rows;
+    private rowHeight;
+    private colWidth;
     private rowspan;
     private colspan;
     private rowspanParent;
@@ -367,6 +636,164 @@ declare class MatrixBrain extends Logger {
     destroy: () => void;
 }
 
+declare type RowSelectionStateItem = (any | any[])[];
+declare type RowSelectionStateObject = {
+    selectedRows: RowSelectionStateItem;
+    deselectedRows: RowSelectionStateItem;
+    defaultSelection: boolean;
+} | {
+    defaultSelection: true;
+    deselectedRows: RowSelectionStateItem;
+    selectedRows?: RowSelectionStateItem;
+} | {
+    defaultSelection: false;
+    selectedRows: RowSelectionStateItem;
+    deselectedRows?: RowSelectionStateItem;
+};
+declare type RowSelectionStateConfig<T> = {
+    groupBy: DataSourceState<T>['groupBy'];
+    groupDeepMap: DataSourceState<T>['groupDeepMap'];
+    totalCount: number;
+    indexer: DataSourceState<T>['indexer'];
+    lazyLoad: boolean;
+};
+declare type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
+declare type RowSelectionStateOverrideForTesting = {
+    getGroupKeysForPrimaryKey: RowSelectionState<any>['getGroupKeysForPrimaryKey'];
+    getGroupByLength: RowSelectionState<any>['getGroupByLength'];
+    getGroupCount: RowSelectionState<any>['getGroupCount'];
+    getGroupKeysDirectlyInsideGroup: RowSelectionState<any>['getGroupKeysDirectlyInsideGroup'];
+};
+declare class RowSelectionState<T = any> {
+    selectedRows: RowSelectionStateItem | null;
+    deselectedRows: RowSelectionStateItem | null;
+    defaultSelection: boolean;
+    selectedMap: DeepMap<any, true>;
+    deselectedMap: DeepMap<any, true>;
+    selectionCache: DeepMap<any, boolean | null>;
+    selectionCountCache: DeepMap<any, {
+        selectedCount: number;
+        deselectedCount: number;
+    }>;
+    getConfig: GetRowSelectionStateConfig<T>;
+    getGroupKeysForPrimaryKey(pk: any): any[];
+    getGroupDeepMap(): DeepMap<any, DeepMapGroupValueType<T, any>> | undefined;
+    getGroupCount(groupKeys: any[]): number;
+    getGroupKeysDirectlyInsideGroup(groupKeys: any[]): any[][];
+    getGroupByLength(): number;
+    static from<T>(rowSeleStateObject: RowSelectionStateObject, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverrideForTesting): RowSelectionState<T>;
+    constructor(state: RowSelectionStateObject | RowSelectionState, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverrideForTesting);
+    mapSet: (name: 'selected' | 'deselected', key: any | any[]) => void;
+    _selectedMapSet: (key: any | any[]) => void;
+    _deselectedMapSet: (key: any | any[]) => void;
+    update(stateObject: RowSelectionStateObject): void;
+    private xcache;
+    getState(): RowSelectionStateObject;
+    deselectAll(): void;
+    selectAll(): void;
+    isRowDefaultSelected(): boolean;
+    isRowDefaultDeselected(): boolean;
+    /**
+     *
+     * @param key the id of the row - if a row in a grouped datasource, this is the final row id, without the group keys
+     * @param groupKeys the keys of row parents, in order
+     * @returns Whether the row is selected or not.
+     */
+    isRowSelected(key: any, groupKeys?: any[]): boolean;
+    isRowDeselected(key: any, groupKeys?: any[]): boolean;
+    setRowSelected(key: string | number, selected: boolean, groupKeys?: any[]): void;
+    /**
+     * Returns if the selection state ('full','partial','none') for the current group
+     *
+     * The selection state will be full (true) if either of those are true:
+     *  * the group keys are specified as selected
+     *  * all the children are specified as selected
+     *
+     * The selection state will be partial (null) if either of those are true:
+     *  * the group keys are partially selected
+     *  * some of the children are specified as selected
+     *
+     *
+     * @param groupKeys the keys of the group row
+     * @param children leaf children that belong to the group
+     * @returns boolean
+     */
+    getGroupRowSelectionState(initialGroupKeys: any[]): boolean | null;
+    private getGroupRowBooleanSelectionStateFromParent;
+    isGroupRowPartlySelected(groupKeys: any[]): boolean;
+    isGroupRowSelected(groupKeys: any[]): boolean;
+    isGroupRowDeselected(groupKeys: any[]): boolean;
+    selectGroupRow(groupKeys: any[]): void;
+    deselectGroupRow(groupKeys: any[]): void;
+    setRowAsSelected(key: string | number, groupKeys?: any[]): void;
+    setRowAsDeselected(key: string | number, groupKeys?: any[]): void;
+    deselectRow(key: any, groupKeys?: any[]): void;
+    selectRow(key: any, groupKeys?: any[]): void;
+    toggleGroupRowSelection(groupKeys: any[]): void;
+    toggleRowSelection(key: string | number, groupKeys?: any[] | undefined): void;
+    getSelectedCount(): number;
+    getDeselectedCount(): number;
+    getSelectionCountFor(groupKeys?: any[], parentSelected?: boolean): {
+        selectedCount: number;
+        deselectedCount: number;
+    };
+}
+
+declare type MultiRowSelectorOptions = {
+    getIdForIndex: (index: number) => string | number;
+};
+declare class MultiRowSelector {
+    getIdForIndex: MultiRowSelectorOptions['getIdForIndex'];
+    multiSelectStartIndex: number;
+    multiSelectEndIndex?: number;
+    _rowSelectionState: RowSelectionState;
+    constructor(options: MultiRowSelectorOptions);
+    set rowSelectionState(rowSelectionState: RowSelectionState);
+    get rowSelectionState(): RowSelectionState;
+    private selectRange;
+    private deselectRange;
+    /**
+     * This is the single click, without any modifier
+     */
+    resetClick(index: number): void;
+    /**
+     * This is the click with ctrl/cmd key pressed
+     * @param index
+     */
+    singleAddClick(index: number): void;
+    multiSelectClick(index: number): void;
+}
+
+interface InfiniteTableComputedValues<T> {
+    scrollbars: {
+        vertical: boolean;
+        horizontal: boolean;
+    };
+    multiRowSelector: MultiRowSelector;
+    showColumnFilters: boolean;
+    renderSelectionCheckBox: boolean;
+    rowspan?: MatrixBrainOptions['rowspan'];
+    computedPinnedStartOverflow: boolean;
+    computedPinnedEndOverflow: boolean;
+    computedPinnedStartColumns: InfiniteTableComputedColumn<T>[];
+    computedPinnedEndColumns: InfiniteTableComputedColumn<T>[];
+    computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
+    computedVisibleColumns: InfiniteTableComputedColumn<T>[];
+    computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
+    computedColumnVisibility: InfiniteTablePropColumnVisibility;
+    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
+    computedPinnedStartColumnsWidth: number;
+    computedPinnedStartWidth: number;
+    computedPinnedEndColumnsWidth: number;
+    computedPinnedEndWidth: number;
+    computedUnpinnedColumnsWidth: number;
+    computedUnpinnedOffset: number;
+    computedPinnedEndOffset: number;
+    computedRemainingSpace: number;
+    toggleGroupRow: (groupKeys: any[]) => void;
+    columnSize: (colIndex: number) => number;
+}
+
 declare type TableRenderCellFnParam = {
     domRef: RefCallback<HTMLElement>;
     rowIndex: number;
@@ -459,21 +886,10 @@ declare class ReactHeadlessTableRenderer extends Logger {
     reset(): void;
 }
 
-declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
-    getComponentState: () => T_STATE;
-    componentState: T_STATE;
-    componentActions: T_ACTIONS;
-};
-declare type ComponentStateGeneratedActions<T_STATE> = {
-    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
-};
-declare type ComponentInterceptedActions<T_STATE> = {
-    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
-        actions: ComponentStateGeneratedActions<T_STATE>;
-        state: T_STATE;
-    }) => void | boolean;
+declare type CellPosition = {
+    rowIndex: number;
+    colIndex: number;
 };
-declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
 
 declare type NonUndefined<T> = T extends undefined ? never : T;
 
@@ -506,7 +922,11 @@ interface InfiniteTableSetupState<T> {
     activeCellIndicatorDOMRef: MutableRefObject<HTMLDivElement | null>;
     onRowHeightCSSVarChange: SubscriptionCallback<number>;
     onColumnHeaderHeightCSSVarChange: SubscriptionCallback<number>;
-    columnsWhenGrouping?: InfiniteTablePropColumnsMap<T>;
+    cellClick: SubscriptionCallback<CellPosition & {
+        event: MouseEvent;
+    }>;
+    keyDown: SubscriptionCallback<KeyboardEvent>;
+    columnsWhenGrouping?: InfiniteTableColumnsMap<T>;
     bodySize: Size;
     brain: MatrixBrain;
     headerBrain: MatrixBrain;
@@ -531,7 +951,7 @@ interface InfiniteTableMappedState<T> {
     columnPinning: InfiniteTablePropColumnPinning;
     loadingText: InfiniteTableProps<T>['loadingText'];
     components: InfiniteTableProps<T>['components'];
-    columns: InfiniteTablePropColumnsMap<T>;
+    columns: InfiniteTableColumnsMap<T>;
     pivotColumns: InfiniteTableProps<T>['pivotColumns'];
     onReady: InfiniteTableProps<T>['onReady'];
     onSelfFocus: InfiniteTableProps<T>['onSelfFocus'];
@@ -567,6 +987,7 @@ interface InfiniteTableMappedState<T> {
     draggableColumns: NonUndefined<InfiniteTableProps<T>['draggableColumns']>;
     sortable: NonUndefined<InfiniteTableProps<T>['sortable']>;
     hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
+    keyboardSelection: NonUndefined<InfiniteTableProps<T>['keyboardSelection']>;
     columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
     showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
     showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
@@ -600,499 +1021,374 @@ declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<
 interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
 }
 
-declare type LoadMaskProps = {
-    visible: boolean;
-    children: Renderable;
-};
-declare type InfiniteTablePropColumnOrderNormalized = string[];
-declare type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
-declare type InfiniteTablePropColumnVisibility = Record<string, false>;
-declare type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
-declare type InfiniteTablePropColumnPinning = Record<string, true | 'start' | 'end'>;
-declare type InfiniteTableRowStyleFnParams<T> = {
-    rowIndex: number;
-} & InfiniteTableRowInfoDataDiscriminator<T>;
-declare type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
-declare type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
-declare type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
-declare type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
-declare type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
-    getter?: AggregationReducer<T, AggregationResultType>['getter'];
-    field?: keyof T;
+interface InfiniteTableContextValue<T> {
+    imperativeApi: InfiniteTableApi<T>;
+    componentState: InfiniteTableState<T>;
+    componentActions: InfiniteTableActions<T>;
+    computed: InfiniteTableComputedValues<T>;
+    getComputed: () => InfiniteTableComputedValues<T>;
+    getState: () => InfiniteTableState<T>;
+}
+
+declare type RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
 };
-declare type InfiniteTableColumnType<T> = {
-    minWidth?: number;
-    maxWidth?: number;
-    filterType?: string;
-    sortType?: string;
-    dataType?: InfiniteTableDataTypeNames;
-    defaultWidth?: number;
-    defaultFlex?: number;
-    defaultPinned?: InfiniteTableColumnPinnedValues;
-    defaultFilterable?: boolean;
-    defaultHiddenWhenGroupedBy?: InfiniteTableColumn<T>['defaultHiddenWhenGroupedBy'];
-    header?: InfiniteTableColumn<T>['header'];
-    comparer?: InfiniteTableColumn<T>['comparer'];
-    draggable?: InfiniteTableColumn<T>['draggable'];
-    sortable?: InfiniteTableColumn<T>['sortable'];
-    resizable?: InfiniteTableColumn<T>['resizable'];
-    align?: InfiniteTableColumn<T>['align'];
-    verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
-    columnGroup?: string;
-    cssEllipsis?: boolean;
-    headerCssEllipsis?: boolean;
-    field?: keyof T;
-    components?: InfiniteTableColumn<T>['components'];
-    renderValue?: InfiniteTableColumn<T>['renderValue'];
-    render?: InfiniteTableColumn<T>['render'];
-    valueGetter?: InfiniteTableColumn<T>['valueGetter'];
-    valueFormatter?: InfiniteTableColumn<T>['valueFormatter'];
-    style?: InfiniteTableColumn<T>['style'];
-    headerStyle?: InfiniteTableColumn<T>['headerStyle'];
-    headerClassName?: InfiniteTableColumn<T>['headerClassName'];
-};
-declare type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
-declare type InfiniteTableColumnSizingOptions = {
-    flex?: number;
-    width?: number;
-    minWidth?: number;
-    maxWidth?: number;
-};
-declare type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
-declare type InfiniteTableImperativeApi<T> = {
-    setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
-    setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
-    x?: T;
-    get scrollLeft(): number;
-    set scrollLeft(value: number);
-    get scrollTop(): number;
-    set scrollTop(value: number);
-    scrollRowIntoView: (rowIndex: number, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-    }) => boolean;
-    scrollColumnIntoView: (colId: string, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-    }) => boolean;
-    scrollCellIntoView: (rowIndex: number, colIdOrIndex: string | number, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-    }) => boolean;
-    getState: () => InfiniteTableState<T>;
-    getDataSourceState: () => DataSourceState<T>;
-};
-declare type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
-declare type InfiniteTablePropColumnsMap<T, ColumnType = InfiniteTableColumn<T>> = Map<string, ColumnType>;
-declare type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = InfiniteTablePropColumnsMap<T, ColumnType> | Record<string, ColumnType>;
-declare type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
-declare type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
-declare type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
-declare type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
-declare type InfiniteTableColumnGroupHeaderRenderParams = {
-    columnGroup: InfiniteTableComputedColumnGroup;
-};
-declare type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
-declare type InfiniteTableColumnGroup = {
-    columnGroup?: string;
-    header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
-};
-declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
-    id: string;
-    groupOffset: number;
-    computedWidth: number;
-    uniqueGroupId: string[];
-    columns: string[];
-    depth: number;
-};
-declare type InfiniteTableGroupColumnGetterOptions<T> = {
-    groupIndexForColumn?: number;
-    groupByForColumn?: DataSourceGroupBy<T>;
-    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
-    groupCount: number;
-    groupBy: DataSourceGroupBy<T>[];
-    pivotBy?: DataSourcePivotBy<T>[];
-};
-declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
-    column: COL_TYPE;
-    groupBy: DataSourcePropGroupBy<T>;
-    pivotBy: DataSourcePropPivotBy<T>;
-};
-declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
-declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
-    renderGroupIcon?: InfiniteTableGroupColumnRenderIconFunction<T>;
+
+declare type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
+declare type BooleanDeepCollectionStateObject<KeyType> = {
+    positiveItems: BooleanDeepCollectionStateKeys<KeyType>;
+    negativeItems: BooleanDeepCollectionStateKeys<KeyType>;
+};
+declare abstract class BooleanDeepCollectionState<StateObject, KeyType extends any = any> {
+    protected positiveMap?: DeepMap<KeyType, true>;
+    protected negativeMap?: DeepMap<KeyType, true>;
+    protected allNegative: boolean;
+    protected allPositive: boolean;
+    private initialState;
+    constructor(state: BooleanDeepCollectionStateObject<KeyType> | BooleanDeepCollectionState<StateObject, KeyType>);
+    abstract getPositiveFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
+    abstract getNegativeFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
+    abstract getState(): StateObject;
+    protected getInitialState(): BooleanDeepCollectionStateObject<KeyType>;
+    destroy(): void;
+    private update;
+    protected areAllNegative(): boolean;
+    protected areAllPositive(): boolean;
+    protected makeAllNegative(): void;
+    protected makeAllPositive(): void;
+    protected isItemPositive(keys: KeyType[]): boolean | undefined;
+    protected isItemNegative(keys: KeyType[]): boolean;
+    protected setItemValue(keys: KeyType[], shouldMakePositive: boolean): void;
+    protected makeItemNegative(keys: KeyType[]): void;
+    protected makeItemPositive(keys: KeyType[]): void;
+    protected toggleItem(keys: KeyType[]): void;
+}
+
+declare class GroupRowsState<KeyType extends any = any> extends BooleanDeepCollectionState<DataSourcePropGroupRowsStateObject<KeyType>, KeyType> {
+    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
+    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
+    getPositiveFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
+    getNegativeFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
+    areAllCollapsed(): boolean;
+    areAllExpanded(): boolean;
+    collapseAll(): void;
+    expandAll(): void;
+    isGroupRowExpanded(keys: KeyType[]): boolean | undefined;
+    isGroupRowCollapsed(keys: KeyType[]): boolean;
+    setGroupRowExpanded(keys: KeyType[], shouldExpand: boolean): void;
+    collapseGroupRow(keys: KeyType[]): void;
+    expandGroupRow(keys: KeyType[]): void;
+    toggleGroupRow(keys: KeyType[]): void;
+}
+
+declare class Indexer<DataType, PrimaryKeyType = string> {
+    primaryKeyToData: Map<string, DataType>;
+    add: (primaryKey: PrimaryKeyType, data: DataType) => void;
+    clear: () => void;
+    getDataForPrimaryKey: (primaryKey: PrimaryKeyType) => DataType | undefined;
+    indexArray: (arr: DataType[], toPrimaryKey: (data: DataType) => PrimaryKeyType) => void;
+}
+
+interface DataSourceDataParams<T> {
+    originalDataArray: T[];
+    sortInfo?: DataSourceSortInfo<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    filterValue?: DataSourcePropFilterValue<T>;
+    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
+    lazyLoadBatchSize?: number;
+    lazyLoadStartIndex?: number;
+    groupKeys?: any[];
+    append?: boolean;
+    aggregationReducers?: DataSourcePropAggregationReducers<T>;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    __cursorId?: DataSourceSetupState<T>['cursorId'];
+    changes?: DataSourceDataParamsChanges<T>;
+}
+declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
+declare type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
+    field?: keyof T;
     id?: string;
 };
-declare type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
-    renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
-};
-declare type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
-declare type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
-declare type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
-declare type InfiniteTablePropComponents = {
-    LoadMask?: React$1.FC<LoadMaskProps>;
-};
-declare type ScrollStopInfo = {
-    scrollTop: number;
-    firstVisibleRowIndex: number;
-    lastVisibleRowIndex: number;
+declare type DataSourceGroupBy<T> = GroupBy<T, any>;
+declare type DataSourcePivotBy<T> = PivotBy<T, any>;
+declare type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
+declare type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
+declare type DataSourceRemoteData<T> = {
+    data: T[] | LazyGroupDataItem<T>[];
+    mappings?: DataSourceMappings;
+    cache?: boolean;
+    error?: string;
+    totalCount?: number;
+    totalCountUnfiltered?: number;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
 };
-declare type InfiniteTablePropFilterEditors<T> = Record<string, React$1.FC<InfiniteTableFilterEditorProps<T>>>;
-declare type InfiniteTableFilterEditorProps<T extends any> = {
-    filterType: string;
-    operator: string;
-    ariaLabel: string;
-    filterValue: T;
-    className: string;
-    onChange: (value: T | undefined) => void;
+declare type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
+declare type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
+declare type DataSourcePropGroupRowsStateObject<KeyType> = {
+    expandedRows: DataSourceGroupRowsList<KeyType>;
+    collapsedRows: DataSourceGroupRowsList<KeyType>;
 };
-interface InfiniteTableProps<T> {
-    columns: InfiniteTablePropColumns<T>;
-    pivotColumns?: InfiniteTablePropColumnsMap<T, InfiniteTablePivotColumn<T>>;
-    loadingText?: Renderable;
-    components?: InfiniteTablePropComponents;
-    viewportReservedWidth?: number;
-    onViewportReservedWidthChange?: (viewportReservedWidth: number) => void;
-    pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
-    pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
-    pivotGrandTotalColumnPosition?: InfiniteTablePropPivotGrandTotalColumnPosition;
-    groupColumn?: Partial<InfiniteTablePropGroupColumn<T>>;
-    groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
-    hideEmptyGroupColumns?: boolean;
-    columnVisibility?: InfiniteTablePropColumnVisibility;
-    defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
-    pinnedStartMaxWidth?: number;
-    pinnedEndMaxWidth?: number;
-    columnPinning?: InfiniteTablePropColumnPinning;
-    defaultColumnPinning?: InfiniteTablePropColumnPinning;
-    columnSizing?: InfiniteTablePropColumnSizing;
-    defaultColumnSizing?: InfiniteTablePropColumnSizing;
-    onColumnSizingChange?: (columnSizing: InfiniteTablePropColumnSizing) => void;
-    pivotColumnGroups?: InfiniteTablePropColumnGroups;
-    columnGroups?: InfiniteTablePropColumnGroups;
-    defaultColumnGroups?: InfiniteTablePropColumnGroups;
-    defaultCollapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
-    collapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
-    onScrollbarsChange?: (scrollbars: Scrollbars) => void;
-    onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
-    columnTypes?: InfiniteTablePropColumnTypes<T>;
-    showSeparatePivotColumnForSingleAggregation?: boolean;
-    rowHeight: number | string;
-    rowStyle?: InfiniteTablePropRowStyle<T>;
-    rowClassName?: InfiniteTablePropRowClassName<T>;
-    columnHeaderHeight: number | string;
-    domProps?: React$1.HTMLProps<HTMLDivElement>;
-    showZebraRows?: boolean;
-    showHoverRows?: boolean;
-    sortable?: boolean;
-    keyboardNavigation?: InfiniteTablePropKeyboardNavigation;
-    defaultActiveRowIndex?: number | null;
-    activeRowIndex?: number | null;
-    onActiveRowIndexChange?: (activeRowIndex: number) => void;
-    onActiveCellIndexChange?: (activeCellIndex: [number, number]) => void;
-    activeCellIndex?: [number, number] | null;
-    defaultActiveCellIndex?: [number, number] | null;
-    draggableColumns?: boolean;
-    header?: boolean;
-    headerOptions?: InfiniteTablePropHeaderOptions;
-    focusedClassName?: string;
-    focusedWithinClassName?: string;
-    focusedStyle?: React$1.CSSProperties;
-    focusedWithinStyle?: React$1.CSSProperties;
-    columnCssEllipsis?: boolean;
-    columnHeaderCssEllipsis?: boolean;
-    columnDefaultWidth?: number;
-    columnMinWidth?: number;
-    columnMaxWidth?: number;
-    resizableColumns?: boolean;
-    virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
-    virtualizeRows?: boolean;
-    onSelfFocus?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onSelfBlur?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onFocusWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onBlurWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onScrollToTop?: () => void;
-    onScrollToBottom?: () => void;
-    scrollStopDelay?: number;
-    onScrollStop?: (param: ScrollStopInfo) => void;
-    scrollToBottomOffset?: number;
-    defaultColumnOrder?: InfiniteTablePropColumnOrder;
-    columnOrder?: InfiniteTablePropColumnOrder;
-    onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrderNormalized) => void;
-    onRowHeightChange?: (rowHeight: number) => void;
-    filterEditors?: InfiniteTablePropFilterEditors<T>;
-    onReady?: (api: InfiniteTableImperativeApi<T>) => void;
-    rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStyleFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
-    licenseKey?: string;
-    scrollTopKey?: string | number;
-    autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
+declare type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
+declare type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
+interface DataSourceMappedState<T> {
+    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
+    livePagination: DataSourceProps<T>['livePagination'];
+    isRowSelected: DataSourceProps<T>['isRowSelected'];
+    lazyLoad: DataSourceProps<T>['lazyLoad'];
+    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
+    data: DataSourceProps<T>['data'];
+    sortMode: DataSourceProps<T>['sortMode'];
+    filterFunction: DataSourceProps<T>['filterFunction'];
+    filterValue: DataSourceProps<T>['filterValue'];
+    filterTypes: NonUndefined<DataSourceProps<T>['filterTypes']>;
+    primaryKey: DataSourceProps<T>['primaryKey'];
+    filterDelay: NonUndefined<DataSourceProps<T>['filterDelay']>;
+    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
+    groupRowsState: GroupRowsState<T>;
+    pivotBy: DataSourceProps<T>['pivotBy'];
+    loading: NonUndefined<DataSourceProps<T>['loading']>;
+    sortTypes: NonUndefined<DataSourceProps<T>['sortTypes']>;
+    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
+    sortInfo: DataSourceSingleSortInfo<T>[] | null;
 }
-declare type InfiniteTablePropKeyboardNavigation = 'cell' | 'row' | false;
-declare type InfiniteTablePropHeaderOptions = {
-    alwaysReserveSpaceForSortIcon: boolean;
-};
-declare type InfiniteTablePropAutoSizeColumnsKey = string | number | {
-    key: string | number;
-    columnsToSkip?: string[];
-    columnsToResize?: string[];
-    includeHeader?: boolean;
+declare type DataSourceAggregationReducer<T, AggregationResultType> = {
+    name?: string;
+    field?: keyof T;
+    initialValue?: AggregationResultType;
+    getter?: (data: T) => any;
+    reducer: string | ((accumulator: any, value: any, data: T, index: number, groupKeys: any[] | undefined) => AggregationResultType | any);
+    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+    pivotColumn?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<T>>> | (({ column, }: {
+        column: InfiniteTablePivotFinalColumnVariant<T>;
+    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotColumn<T>>>);
 };
-declare type Scrollbars = {
-    vertical: boolean;
-    horizontal: boolean;
+declare type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
+    inheritFromColumn?: string | boolean;
 };
-declare type ScrollAdjustPosition = 'start' | 'end' | 'center';
-
-interface InfiniteTableComputedValues<T> {
-    scrollbars: {
-        vertical: boolean;
-        horizontal: boolean;
+declare type DataSourceMappings = Record<'totals' | 'values', string>;
+declare type LazyGroupDataItem<DataType> = {
+    data: Partial<DataType>;
+    keys: any[];
+    aggregations?: Record<string, any>;
+    dataset?: DataSourceRemoteData<DataType>;
+    totalChildrenCount?: number;
+    pivot?: {
+        values: Record<string, any>;
+        totals?: Record<string, any>;
     };
-    showColumnFilters: boolean;
-    rowspan?: MatrixBrainOptions['rowspan'];
-    computedPinnedStartOverflow: boolean;
-    computedPinnedEndOverflow: boolean;
-    computedPinnedStartColumns: InfiniteTableComputedColumn<T>[];
-    computedPinnedEndColumns: InfiniteTableComputedColumn<T>[];
-    computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
-    computedVisibleColumns: InfiniteTableComputedColumn<T>[];
-    computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
-    computedColumnVisibility: InfiniteTablePropColumnVisibility;
-    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
-    computedPinnedStartColumnsWidth: number;
-    computedPinnedStartWidth: number;
-    computedPinnedEndColumnsWidth: number;
-    computedPinnedEndWidth: number;
-    computedUnpinnedColumnsWidth: number;
-    computedUnpinnedOffset: number;
-    computedPinnedEndOffset: number;
-    computedRemainingSpace: number;
-    toggleGroupRow: (groupKeys: any[]) => void;
-    columnSize: (colIndex: number) => number;
-}
-
-interface InfiniteTableContextValue<T> {
-    imperativeApi: InfiniteTableImperativeApi<T>;
-    componentState: InfiniteTableState<T>;
-    componentActions: InfiniteTableActions<T>;
-    computed: InfiniteTableComputedValues<T>;
-    getComputed: () => InfiniteTableComputedValues<T>;
-    getState: () => InfiniteTableState<T>;
-}
-
-declare type InfiniteTableBaseCellProps<T> = {
-    column: InfiniteTableComputedColumn<T>;
-    renderChildren: () => Renderable;
-    width: number;
-    cssEllipsis?: boolean;
-    contentStyle?: CSSProperties;
-    contentClassName?: string;
-    virtualized?: boolean;
-    skipColumnShifting?: boolean;
-    beforeChildren?: Renderable;
-    afterChildren?: Renderable;
-    cssPosition?: CSSProperties['position'];
-    domRef?: React.RefCallback<HTMLElement>;
 };
-declare type InfiniteTableCellProps<T> = ({
-    cellType: 'header';
-} & InfiniteTableBaseCellProps<T>) | ({
-    cellType: 'body';
-} & InfiniteTableBaseCellProps<T>);
-
-declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-}[Keys];
-declare type DiscriminatedUnion<A, B> = (A & {
-    [K in keyof B]?: undefined;
-}) | (B & {
-    [K in keyof A]?: undefined;
+declare type LazyRowInfoGroup<DataType> = {
+    /**
+     * Those are direct children of the current lazy group row
+     */
+    children: LazyGroupDataItem<DataType>[];
+    childrenLoading: boolean;
+    childrenAvailable: boolean;
+    cache: boolean;
+    totalCount: number;
+    totalCountUnfiltered: number;
+    error?: string;
+};
+declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
+interface DataSourceSetupState<T> {
+    indexer: Indexer<T, any>;
+    unfilteredCount: number;
+    filteredCount: number;
+    lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+    pivotMappings?: DataSourceMappings;
+    propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
+    showSeparatePivotColumnForSingleAggregation: boolean;
+    dataParams?: DataSourceDataParams<T>;
+    originalLazyGroupData: LazyGroupDataDeepMap<T>;
+    originalLazyGroupDataChangeDetect: number | string;
+    scrollStopDelayUpdatedByTable: number;
+    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
+    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
+    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
+    originalDataArray: T[];
+    lastFilterDataArray?: T[];
+    lastSortDataArray?: T[];
+    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
+    dataArray: InfiniteTableRowInfo<T>[];
+    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
+    reducerResults?: Record<string, AggregationReducerResult>;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
+    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
+    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
+    updatedAt: number;
+    reducedAt: number;
+    groupedAt: number;
+    sortedAt: number;
+    filteredAt: number;
+    generateGroupRows: boolean;
+    postFilterDataArray?: T[];
+    postSortDataArray?: T[];
+    postGroupDataArray?: InfiniteTableRowInfo<T>[];
+    pivotColumns?: Map<string, InfiniteTableColumn<T>>;
+    pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
+}
+declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
+declare type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
+declare type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
+declare type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
+declare type DataSourcePropRowSelection_SingleRow = null | string | number;
+declare type DataSourcePropCellSelection = any;
+declare type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
+declare type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
+declare type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
+declare type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
+declare type DataSourcePropOnCellSelectionChange = (cellSelectionParams: any) => void;
+declare type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
+declare type DataSourceProps<T> = {
+    children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
+    primaryKey: keyof T | ((data: T) => string);
+    fields?: (keyof T)[];
+    data: DataSourceData<T>;
+    selectionMode?: DataSourcePropSelectionMode;
+    rowSelection?: DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
+    defaultRowSelection?: DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
+    cellSelection?: DataSourcePropCellSelection;
+    defaultCellSelection?: DataSourcePropCellSelection;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange;
+    isRowSelected?: DataSourcePropIsRowSelected<T>;
+    lazyLoad?: boolean | {
+        batchSize?: number;
+    };
+    loading?: boolean;
+    defaultLoading?: boolean;
+    onLoadingChange?: (loading: boolean) => void;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    defaultPivotBy?: DataSourcePropPivotBy<T>;
+    onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
+    aggregationReducers?: DataSourcePropAggregationReducers<T>;
+    defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    defaultGroupBy?: DataSourcePropGroupBy<T>;
+    onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
+    groupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
+    defaultGroupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<keyof T>;
+    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
+    collapseGroupRowsOnDataFunctionChange?: boolean;
+    sortInfo?: DataSourceSortInfo<T>;
+    defaultSortInfo?: DataSourceSortInfo<T>;
+    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
+    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
+    livePagination?: boolean;
+    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
+    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
+    filterFunction?: DataSourcePropFilterFunction<T>;
+    sortMode?: 'local' | 'remote';
+    filterMode?: 'local' | 'remote';
+    filterValue?: DataSourcePropFilterValue<T>;
+    defaultFilterValue?: DataSourcePropFilterValue<T>;
+    onFilterValueChange?: (filterValue: DataSourcePropFilterValue<T>) => void;
+    filterDelay?: number;
+    filterTypes?: DataSourcePropFilterTypes<T>;
+    sortTypes?: DataSourcePropSortTypes;
+} & ({
+    selectionMode?: 'multi-row';
+    rowSelection?: DataSourcePropRowSelection_MultiRow;
+    defaultRowSelection?: DataSourcePropRowSelection_MultiRow;
+    onRowSelectionChange?: DataSourcePropOnRowSelectionChange_MultiRow;
+} | {
+    selectionMode?: 'single-row';
+    rowSelection?: DataSourcePropRowSelection_SingleRow;
+    defaultRowSelection?: DataSourcePropRowSelection_SingleRow;
+    onRowSelectionChange?: DataSourcePropOnRowSelectionChange_SingleRow;
+} | {
+    selectionMode?: 'single-cell';
+} | {
+    selectionMode?: 'multi-cell';
+} | {
+    selectionMode?: false;
 });
-
-declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
-declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    sortTool: JSX.Element | null;
-    dragging: boolean;
-    column: COL_TYPE;
-    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
-    columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
-};
-declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    value: string | number | Renderable;
-    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
-    rowIndex: number;
-    rowActive: boolean;
-    column: COL_TYPE;
-    toggleCurrentGroupRow: () => void;
-    toggleGroupRow: InfiniteTableToggleGroupRowFn;
-    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
-    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
-};
-declare type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
-declare type InfiniteTableGroupColumnRenderParams<DATA_TYPE, COL_TYPE> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & {
-    rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<DATA_TYPE>;
-    isGroupRow: true;
-    data: Partial<DATA_TYPE> | null;
-};
-declare type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParam<DATA_TYPE> & {};
-declare type InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableGroupColumnRenderParams<DATA_TYPE, COL_TYPE> & {
-    collapsed: boolean;
-    groupIcon: Renderable;
-};
-declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
-declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
-    data: DATA_TYPE | Partial<DATA_TYPE> | null;
-    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
-    rowIndex: number;
-    column: COL_TYPE;
-};
-declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableGroupColumnRenderIconFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (param: InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParams<T>) => Renderable;
-declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
-declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
-declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
-declare type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
-declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
-declare type InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T> = RequireAtLeastOne<{
-    /**
-     * Determines the field property of the column.
-     */
-    field?: keyof T;
-    render?: InfiniteTableColumnRenderFunction<T>;
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
-    valueFormatter?: InfiniteTableColumnValueFormatter<T>;
-}, 'render' | 'renderValue' | 'field' | 'valueGetter' | 'valueFormatter'>;
-declare type InfiniteTableColumnStyleFnParams<T> = {
-    value: Renderable;
-    column: InfiniteTableColumn<T>;
-} & InfiniteTableRowInfoDataDiscriminator<T>;
-declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
-declare type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParams<T>) => undefined | string;
-declare type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParams<T>) => undefined | React.CSSProperties;
-declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
-declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
-declare type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
-declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
-declare type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
-declare type InfiniteTableColumnValueGetterParams<T> = {
+declare type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
+declare type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
+declare type DataSourceFilterFunctionParam<T> = {
     data: T;
-    field?: keyof T;
+    index: number;
+    dataArray: T[];
+    primaryKey: any;
 };
-declare type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
-declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
-declare type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
-declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
-declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
-declare type InfiniteTableBaseColumn<T> = {
-    sortable?: boolean;
-    draggable?: boolean;
-    resizable?: boolean;
-    comparer?: InfiniteTableColumnComparer<T>;
-    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
-        [k in keyof Partial<T>]: true;
-    };
-    align?: InfiniteTableColumnAlign;
-    verticalAlign?: InfiniteTableColumnVerticalAlign;
-    columnGroup?: string;
-    header?: InfiniteTableColumnHeader<T>;
-    name?: Renderable;
-    cssEllipsis?: boolean;
-    headerCssEllipsis?: boolean;
-    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
-    dataType?: InfiniteTableDataTypeNames;
-    sortType?: string;
-    filterType?: string;
-    style?: InfiniteTableColumnStyle<T>;
-    headerStyle?: InfiniteTableColumnHeaderStyle<T>;
-    headerClassName?: InfiniteTableColumnHeaderClassName<T>;
-    className?: InfiniteTableColumnClassName<T>;
-    rowspan?: InfiniteTableColumnRowspanFn<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
-    valueFormatter?: InfiniteTableColumnValueFormatter<T>;
-    defaultWidth?: number;
-    defaultFlex?: number;
-    defaultFilterable?: boolean;
-    minWidth?: number;
-    maxWidth?: number;
-    components?: {
-        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
-        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
-    };
+declare type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
+declare type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
+declare type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
+    field: keyof T;
+}, {
+    id: string;
+}> & {
+    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
+    filterValue: any;
+    disabled?: boolean;
+    filterType: string;
+    operator: string;
 };
-/**
- * Defines a column in the table.
- *
- * @typeParam DATA_TYPE The type of the data in the table.
- *
- * Can be bound to a field which is a `keyof DATA_TYPE`.
- */
-declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<DATA_TYPE>;
-declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
-    groupByField: string | string[];
-    id?: string;
+declare type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T>) => any;
+declare type DataSourceFilterType<T> = {
+    emptyValues: Set<any>;
+    label?: string;
+    defaultOperator: string;
+    operators: DataSourceFilterOperator<T>[];
 };
-declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
-declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotTotalColumnGroup?: true;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex: PivotBy<DataType, KeyType>;
-    pivotGroupKey: KeyType;
-    pivotIndex: number;
+declare type DataSourceFilterOperator<T> = {
+    name: string;
+    label?: string;
+    fn: DataSourceFilterOperatorFunction<T>;
 };
-declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotColumn: true;
-    pivotTotalColumn: boolean;
-    pivotAggregator: AggregationReducer<DataType, any>;
-    pivotAggregatorIndex: number;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex?: PivotBy<DataType, KeyType>;
-    pivotIndex: number;
-    pivotGroupKey: KeyType;
+declare type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
+declare type DataSourceFilterOperatorFunctionParam<T> = {
+    currentValue: any;
+    filterValue: any;
+    emptyValues: Set<any>;
+} & DataSourceFilterFunctionParam<T>;
+declare type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
+declare type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
+declare type DataSourceLivePaginationCursorParams<T> = {
+    array: T[];
+    lastItem: T | Partial<T> | null;
+    length: number;
 };
-declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
-declare type InfiniteTableComputedColumnBase<T> = {
-    computedFilterType: string;
-    computedSortType: string;
-    computedDataType: string;
-    computedWidth: number;
-    computedFlex: number | null;
-    computedMinWidth: number;
-    computedMaxWidth: number;
-    computedOffset: number;
-    computedPinningOffset: number;
-    computedAbsoluteOffset: number;
-    computedSortable: boolean;
-    computedSortInfo: DataSourceSingleSortInfo<T> | null;
-    computedSorted: boolean;
-    computedSortedAsc: boolean;
-    computedSortedDesc: boolean;
-    computedSortIndex: number;
-    computedVisibleIndex: number;
-    computedVisibleIndexInCategory: number;
-    computedMultiSort: boolean;
-    computedFiltered: boolean;
-    computedFilterable: boolean;
-    computedFilterValue: DataSourceFilterValueItem<T> | null;
-    computedPinned: InfiniteTableColumnPinnedValues;
-    computedDraggable: boolean;
-    computedResizable: boolean;
-    computedFirstInCategory: boolean;
-    computedLastInCategory: boolean;
-    computedFirst: boolean;
-    computedLast: boolean;
-    toggleSort: () => void;
-    id: string;
+declare type DataSourceLivePaginationCursorValue = string | number | null;
+interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
+}
+declare type DataSourceDerivedState<T> = {
+    toPrimaryKey: (data: T) => any;
+    operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
+    filterMode: NonUndefined<DataSourceProps<T>['filterMode']>;
+    multiSort: boolean;
+    controlledSort: boolean;
+    controlledFilter: boolean;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    lazyLoadBatchSize?: number;
+    rowSelection: RowSelectionState | null | number | string;
+    selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
 };
-declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
-declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
+declare type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
+interface DataSourceContextValue<T> {
+    getState: () => DataSourceState<T>;
+    componentState: DataSourceState<T>;
+    componentActions: DataSourceComponentActions<T>;
+}
+declare enum DataSourceActionType {
+    INIT = "INIT"
+}
+interface DataSourceAction<T> {
+    type: DataSourceActionType;
+    payload: T;
+}
+interface DataSourceReducer<T> {
+    (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
+}
+
+declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
+
+declare function useDataSource<T>(): DataSourceState<T>;
+
+declare function DataSource<T>(props: DataSourceProps<T>): JSX.Element;
 
 declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
     id: string;
@@ -1134,6 +1430,7 @@ declare type InfiniteTable_RowInfoBase<_T> = {
     id: any;
     value?: any;
     indexInAll: number;
+    rowSelected: boolean | null;
 };
 declare type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
     dataSourceHasGrouping: true;
@@ -1154,12 +1451,30 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
     /**
      * The count of all leaf nodes (normal rows) that are inside this group.
      * This count is the same as the length of the groupData array property.
+     *
      */
     groupCount: number;
     /**
      * The array of all leaf nodes (normal rows) that are inside this group.
      */
-    groupData: T[];
+    groupData: T[];
+    /**
+     * The count of all selected leaf nodes (normal rows) inside the group that are selected
+     */
+    selectedChildredCount: number;
+    /**
+     * The count of all deselected leaf nodes (normal rows) inside the group that are selected
+     */
+    deselectedChildredCount: number;
+    /**
+     * Will be used only with lazy loading, if the server provides this info on the data items.
+     *
+     * Represents the total count of all leaf nodes (normal rows) that are under this group
+     * at any level (so not only direct children). This is needed for multiple selection to work properly,
+     * so the table component knows how many rows are on the remote backend, and whether to show a group as selected or not
+     * when it has a certain number of rows selected
+     */
+    totalChildrenCount?: number;
     /**
      * The count of all leaf nodes (normal rows) inside the group that are not being visible
      * due to collapsing (either the current row is collapsed or any of its children)
@@ -1309,6 +1624,7 @@ declare type DeepMapGroupValueType<DataType, KeyType> = {
     commonData?: Partial<DataType>;
     childrenLoading: boolean;
     childrenAvailable: boolean;
+    totalChildrenCount?: number;
     cache: boolean;
     error?: string;
     reducerResults: Record<string, AggregationReducerResult>;
@@ -1344,312 +1660,287 @@ declare type DataGroupResult<DataType, KeyType extends any> = {
 declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
 declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
 
-declare type SortDir = 1 | -1;
-declare type MultisortInfo<T> = {
-    /**
-     * The sorting direction
-     */
-    dir: SortDir;
-    /**
-     * for now 'string' and 'number' are known types, meaning they have
-     * sort functions already implemented
-     */
-    type?: string;
-    fn?: (a: any, b: any) => number;
-    /**
-     * a property whose value to use for sorting on the array items
-     */
-    field?: keyof T;
-    /**
-     * or a function to retrieve the item value to use for sorting
-     */
-    valueGetter?: (item: T) => any;
-};
-declare const multisort: {
-    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
-    knownTypes: {
-        [key: string]: (first: any, second: any) => number;
-    };
-};
+declare type InfiniteCheckBoxPropChecked = true | false | null;
+declare type InfiniteCheckBoxProps = {
+    checked?: InfiniteCheckBoxPropChecked;
+    defaultChecked?: InfiniteCheckBoxPropChecked;
+    onChange?: (checked: InfiniteCheckBoxPropChecked) => void;
+    domProps?: React$1.HTMLProps<HTMLElement>;
+};
+declare function InfiniteCheckBox(props: InfiniteCheckBoxProps): JSX.Element;
 
-declare type RenderRange = {
-    renderStartIndex: number;
-    renderEndIndex: number;
+declare type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
+declare type InfiniteTableSelectionApi = {
+    get allRowsSelected(): boolean;
+    isRowSelected(pk: any, groupKeys?: any[]): boolean;
+    isRowDeselected(pk: any, groupKeys?: any[]): boolean;
+    selectRow(pk: any, groupKeys?: any[]): void;
+    deselectRow(pk: any, groupKeys?: any[]): void;
+    toggleRowSelection(pk: any, groupKeys?: any[]): void;
+    selectGroupRow(groupKeys: any[], children?: ArrayOfIds): void;
+    deselectGroupRow(groupKeys: any[], children?: ArrayOfIds): void;
+    toggleGroupRowSelection(groupKeys: any[], children?: ArrayOfIds): void;
+    getGroupRowSelectionState(groupKeys: any[]): boolean | null;
+    getSelectedPrimaryKeys(): (string | number)[];
+    selectAll(): void;
+    deselectAll(): void;
 };
 
-interface DataSourceDataParams<T> {
-    originalDataArray: T[];
-    sortInfo?: DataSourceSortInfo<T>;
-    groupBy?: DataSourcePropGroupBy<T>;
-    pivotBy?: DataSourcePropPivotBy<T>;
-    filterValue?: DataSourcePropFilterValue<T>;
-    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
-    lazyLoadBatchSize?: number;
-    lazyLoadStartIndex?: number;
-    groupKeys?: any[];
-    append?: boolean;
-    aggregationReducers?: DataSourcePropAggregationReducers<T>;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-    __cursorId?: DataSourceSetupState<T>['cursorId'];
-    changes?: DataSourceDataParamsChanges<T>;
-}
-declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
-declare type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
-    field?: keyof T;
-    id?: string;
-};
-declare type DataSourceGroupBy<T> = GroupBy<T, any>;
-declare type DataSourcePivotBy<T> = PivotBy<T, any>;
-declare type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
-declare type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
-declare type DataSourceRemoteData<T> = {
-    data: T[] | LazyGroupDataItem<T>[];
-    mappings?: DataSourceMappings;
-    cache?: boolean;
-    error?: string;
-    totalCount?: number;
-    totalCountUnfiltered?: number;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-};
-declare type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
-declare type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
-declare type DataSourcePropGroupRowsStateObject<KeyType> = {
-    expandedRows: DataSourceGroupRowsList<KeyType>;
-    collapsedRows: DataSourceGroupRowsList<KeyType>;
+declare type LoadMaskProps = {
+    visible: boolean;
+    children: Renderable;
 };
-declare type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
-declare type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
-interface DataSourceMappedState<T> {
-    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
-    livePagination: DataSourceProps<T>['livePagination'];
-    lazyLoad: DataSourceProps<T>['lazyLoad'];
-    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
-    data: DataSourceProps<T>['data'];
-    sortMode: DataSourceProps<T>['sortMode'];
-    filterFunction: DataSourceProps<T>['filterFunction'];
-    filterValue: DataSourceProps<T>['filterValue'];
-    filterTypes: NonUndefined<DataSourceProps<T>['filterTypes']>;
-    primaryKey: DataSourceProps<T>['primaryKey'];
-    filterDelay: NonUndefined<DataSourceProps<T>['filterDelay']>;
-    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
-    groupRowsState: GroupRowsState<T>;
-    pivotBy: DataSourceProps<T>['pivotBy'];
-    loading: NonUndefined<DataSourceProps<T>['loading']>;
-    sortTypes: NonUndefined<DataSourceProps<T>['sortTypes']>;
-    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
-    sortInfo: DataSourceSingleSortInfo<T>[] | null;
-}
-declare type DataSourceAggregationReducer<T, AggregationResultType> = {
-    name?: string;
+declare type InfiniteTablePropColumnOrderNormalized = string[];
+declare type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
+declare type InfiniteTablePropColumnVisibility = Record<string, false>;
+declare type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
+declare type InfiniteTablePropColumnPinning = Record<string, true | 'start' | 'end'>;
+declare type InfiniteTableRowStyleFnParams<T> = {
+    rowIndex: number;
+} & InfiniteTableRowInfoDataDiscriminator<T>;
+declare type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
+declare type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
+declare type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
+declare type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
+declare type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
+    getter?: AggregationReducer<T, AggregationResultType>['getter'];
     field?: keyof T;
-    initialValue?: AggregationResultType;
-    getter?: (data: T) => any;
-    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
-    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
-    pivotColumn?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<T>>> | (({ column, }: {
-        column: InfiniteTablePivotFinalColumnVariant<T>;
-    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotColumn<T>>>);
-};
-declare type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
-    inheritFromColumn?: string | boolean;
 };
-declare type DataSourceMappings = Record<'totals' | 'values', string>;
-declare type LazyGroupDataItem<DataType> = {
-    data: Partial<DataType>;
-    keys: any[];
-    aggregations?: Record<string, any>;
-    dataset?: DataSourceRemoteData<DataType>;
-    pivot?: {
-        values: Record<string, any>;
-        totals?: Record<string, any>;
-    };
+declare type InfiniteTableColumnType<T> = {
+    minWidth?: number;
+    maxWidth?: number;
+    filterType?: string;
+    sortType?: string;
+    dataType?: InfiniteTableDataTypeNames;
+    defaultWidth?: number;
+    defaultFlex?: number;
+    defaultPinned?: InfiniteTableColumnPinnedValues;
+    defaultFilterable?: boolean;
+    defaultHiddenWhenGroupedBy?: InfiniteTableColumn<T>['defaultHiddenWhenGroupedBy'];
+    header?: InfiniteTableColumn<T>['header'];
+    comparer?: InfiniteTableColumn<T>['comparer'];
+    draggable?: InfiniteTableColumn<T>['draggable'];
+    sortable?: InfiniteTableColumn<T>['sortable'];
+    resizable?: InfiniteTableColumn<T>['resizable'];
+    align?: InfiniteTableColumn<T>['align'];
+    verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
+    columnGroup?: string;
+    cssEllipsis?: boolean;
+    headerCssEllipsis?: boolean;
+    field?: keyof T;
+    components?: InfiniteTableColumn<T>['components'];
+    renderValue?: InfiniteTableColumn<T>['renderValue'];
+    render?: InfiniteTableColumn<T>['render'];
+    valueGetter?: InfiniteTableColumn<T>['valueGetter'];
+    valueFormatter?: InfiniteTableColumn<T>['valueFormatter'];
+    style?: InfiniteTableColumn<T>['style'];
+    headerStyle?: InfiniteTableColumn<T>['headerStyle'];
+    headerClassName?: InfiniteTableColumn<T>['headerClassName'];
 };
-declare type LazyRowInfoGroup<DataType> = {
-    /**
-     * Those are direct children of the current lazy group row
-     */
-    children: LazyGroupDataItem<DataType>[];
-    childrenLoading: boolean;
-    childrenAvailable: boolean;
-    cache: boolean;
-    totalCount: number;
-    totalCountUnfiltered: number;
-    error?: string;
+declare type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
+declare type InfiniteTableColumnSizingOptions = {
+    flex?: number;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
 };
-declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
-interface DataSourceSetupState<T> {
-    unfilteredCount: number;
-    filteredCount: number;
-    lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
-    pivotMappings?: DataSourceMappings;
-    propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
-    showSeparatePivotColumnForSingleAggregation: boolean;
-    dataParams?: DataSourceDataParams<T>;
-    originalLazyGroupData: LazyGroupDataDeepMap<T>;
-    originalLazyGroupDataChangeDetect: number | string;
-    scrollStopDelayUpdatedByTable: number;
-    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
-    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
-    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
-    originalDataArray: T[];
-    lastFilterDataArray?: T[];
-    lastSortDataArray?: T[];
-    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
-    dataArray: InfiniteTableRowInfo<T>[];
-    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
-    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
-    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
-    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
-    updatedAt: number;
-    reducedAt: number;
-    groupedAt: number;
-    sortedAt: number;
-    filteredAt: number;
-    generateGroupRows: boolean;
-    postFilterDataArray?: T[];
-    postSortDataArray?: T[];
-    postGroupDataArray?: InfiniteTableRowInfo<T>[];
-    pivotColumns?: Map<string, InfiniteTableColumn<T>>;
-    pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
-}
-declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
-declare type DataSourceProps<T> = {
-    children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
-    primaryKey: keyof T | (({ data, index }: {
-        data: T;
-        index: number;
-    }) => string);
-    fields?: (keyof T)[];
-    data: DataSourceData<T>;
-    lazyLoad?: boolean | {
-        batchSize?: number;
-    };
-    loading?: boolean;
-    defaultLoading?: boolean;
-    onLoadingChange?: (loading: boolean) => void;
-    pivotBy?: DataSourcePropPivotBy<T>;
-    defaultPivotBy?: DataSourcePropPivotBy<T>;
-    onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
-    aggregationReducers?: DataSourcePropAggregationReducers<T>;
-    defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
-    groupBy?: DataSourcePropGroupBy<T>;
-    defaultGroupBy?: DataSourcePropGroupBy<T>;
-    onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
-    groupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
-    defaultGroupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<keyof T>;
-    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
-    collapseGroupRowsOnDataFunctionChange?: boolean;
-    sortInfo?: DataSourceSortInfo<T>;
-    defaultSortInfo?: DataSourceSortInfo<T>;
-    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
-    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
-    livePagination?: boolean;
-    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
-    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
-    filterFunction?: DataSourcePropFilterFunction<T>;
-    sortMode?: 'local' | 'remote';
-    filterMode?: 'local' | 'remote';
-    filterValue?: DataSourcePropFilterValue<T>;
-    defaultFilterValue?: DataSourcePropFilterValue<T>;
-    onFilterValueChange?: (filterValue: DataSourcePropFilterValue<T>) => void;
-    filterDelay?: number;
-    filterTypes?: DataSourcePropFilterTypes<T>;
-    sortTypes?: DataSourcePropSortTypes;
+declare type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
+declare type InfiniteTableApi<T> = {
+    get selectionApi(): InfiniteTableSelectionApi;
+    setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
+    setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
+    x?: T;
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    toggleGroupRow: (groupKeys: any[]) => void;
+    collapseGroupRow: (groupKeys: any[]) => boolean;
+    expandGroupRow: (groupKeys: any[]) => boolean;
+    scrollRowIntoView: (rowIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => boolean;
+    scrollColumnIntoView: (colId: string, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => boolean;
+    scrollCellIntoView: (rowIndex: number, colIdOrIndex: string | number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => boolean;
+    getState: () => InfiniteTableState<T>;
+    getDataSourceState: () => DataSourceState<T>;
 };
-declare type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
-declare type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
-declare type DataSourceFilterFunctionParam<T> = {
-    data: T;
-    index: number;
-    dataArray: T[];
-    primaryKey: any;
+declare type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
+declare type InfiniteTableColumnsMap<T, ColumnType = InfiniteTableColumn<T>> = Map<string, ColumnType>;
+declare type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = Record<string, ColumnType> | InfiniteTableColumnsMap<T, ColumnType>;
+declare type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
+declare type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
+declare type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
+declare type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
+declare type InfiniteTableColumnGroupHeaderRenderParams = {
+    columnGroup: InfiniteTableComputedColumnGroup;
 };
-declare type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
-declare type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
-declare type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
-    field: keyof T;
-}, {
+declare type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
+declare type InfiniteTableColumnGroup = {
+    columnGroup?: string;
+    header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
+};
+declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
     id: string;
-}> & {
-    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
-    filterValue: any;
-    disabled?: boolean;
+    groupOffset: number;
+    computedWidth: number;
+    uniqueGroupId: string[];
+    columns: string[];
+    depth: number;
+};
+declare type InfiniteTableGroupColumnGetterOptions<T> = {
+    groupIndexForColumn?: number;
+    groupByForColumn?: DataSourceGroupBy<T>;
+    selectionMode: DataSourcePropSelectionMode;
+    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
+    groupCount: number;
+    groupBy: DataSourceGroupBy<T>[];
+    pivotBy?: DataSourcePivotBy<T>[];
+};
+declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
+    column: COL_TYPE;
+    groupBy: DataSourcePropGroupBy<T>;
+    pivotBy: DataSourcePropPivotBy<T>;
+};
+declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
+declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
+    renderValue?: InfiniteTableColumnRenderFunction<T>;
+    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<T>;
+    id?: string;
+};
+declare type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
+    renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
+};
+declare type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
+declare type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
+declare type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
+declare type InfiniteTablePropComponents = {
+    LoadMask?: React$1.FC<LoadMaskProps>;
+    CheckBox?: React$1.FC<InfiniteCheckBoxProps>;
+};
+declare type ScrollStopInfo = {
+    scrollTop: number;
+    firstVisibleRowIndex: number;
+    lastVisibleRowIndex: number;
+};
+declare type InfiniteTablePropFilterEditors<T> = Record<string, React$1.FC<InfiniteTableFilterEditorProps<T>>>;
+declare type InfiniteTableFilterEditorProps<T extends any> = {
     filterType: string;
     operator: string;
+    ariaLabel: string;
+    filterValue: T;
+    className: string;
+    onChange: (value: T | undefined) => void;
 };
-declare type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T>) => any;
-declare type DataSourceFilterType<T> = {
-    emptyValues: Set<any>;
-    label?: string;
-    defaultOperator: string;
-    operators: DataSourceFilterOperator<T>[];
+interface InfiniteTableProps<T> {
+    columns: InfiniteTablePropColumns<T>;
+    pivotColumns?: InfiniteTableColumnsMap<T, InfiniteTablePivotColumn<T>>;
+    loadingText?: Renderable;
+    components?: InfiniteTablePropComponents;
+    viewportReservedWidth?: number;
+    onViewportReservedWidthChange?: (viewportReservedWidth: number) => void;
+    pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
+    pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
+    pivotGrandTotalColumnPosition?: InfiniteTablePropPivotGrandTotalColumnPosition;
+    groupColumn?: Partial<InfiniteTablePropGroupColumn<T>>;
+    groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
+    hideEmptyGroupColumns?: boolean;
+    columnVisibility?: InfiniteTablePropColumnVisibility;
+    defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
+    pinnedStartMaxWidth?: number;
+    pinnedEndMaxWidth?: number;
+    columnPinning?: InfiniteTablePropColumnPinning;
+    defaultColumnPinning?: InfiniteTablePropColumnPinning;
+    columnSizing?: InfiniteTablePropColumnSizing;
+    defaultColumnSizing?: InfiniteTablePropColumnSizing;
+    onColumnSizingChange?: (columnSizing: InfiniteTablePropColumnSizing) => void;
+    pivotColumnGroups?: InfiniteTablePropColumnGroups;
+    columnGroups?: InfiniteTablePropColumnGroups;
+    defaultColumnGroups?: InfiniteTablePropColumnGroups;
+    defaultCollapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
+    collapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
+    onScrollbarsChange?: (scrollbars: Scrollbars) => void;
+    onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
+    columnTypes?: InfiniteTablePropColumnTypes<T>;
+    showSeparatePivotColumnForSingleAggregation?: boolean;
+    rowHeight: number | string;
+    rowStyle?: InfiniteTablePropRowStyle<T>;
+    rowClassName?: InfiniteTablePropRowClassName<T>;
+    columnHeaderHeight: number | string;
+    domProps?: React$1.HTMLProps<HTMLDivElement>;
+    showZebraRows?: boolean;
+    showHoverRows?: boolean;
+    sortable?: boolean;
+    keyboardNavigation?: InfiniteTablePropKeyboardNavigation;
+    keyboardSelection?: InfiniteTablePropKeyboardSelection;
+    defaultActiveRowIndex?: number | null;
+    activeRowIndex?: number | null;
+    onActiveRowIndexChange?: (activeRowIndex: number) => void;
+    onActiveCellIndexChange?: (activeCellIndex: [number, number]) => void;
+    activeCellIndex?: [number, number] | null;
+    defaultActiveCellIndex?: [number, number] | null;
+    draggableColumns?: boolean;
+    header?: boolean;
+    headerOptions?: InfiniteTablePropHeaderOptions;
+    focusedClassName?: string;
+    focusedWithinClassName?: string;
+    focusedStyle?: React$1.CSSProperties;
+    focusedWithinStyle?: React$1.CSSProperties;
+    columnCssEllipsis?: boolean;
+    columnHeaderCssEllipsis?: boolean;
+    columnDefaultWidth?: number;
+    columnMinWidth?: number;
+    columnMaxWidth?: number;
+    resizableColumns?: boolean;
+    virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
+    virtualizeRows?: boolean;
+    onSelfFocus?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onSelfBlur?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onFocusWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onBlurWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onScrollToTop?: () => void;
+    onScrollToBottom?: () => void;
+    scrollStopDelay?: number;
+    onScrollStop?: (param: ScrollStopInfo) => void;
+    scrollToBottomOffset?: number;
+    defaultColumnOrder?: InfiniteTablePropColumnOrder;
+    columnOrder?: InfiniteTablePropColumnOrder;
+    onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrderNormalized) => void;
+    onRowHeightChange?: (rowHeight: number) => void;
+    filterEditors?: InfiniteTablePropFilterEditors<T>;
+    onReady?: (api: InfiniteTableApi<T>) => void;
+    rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStyleFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
+    licenseKey?: string;
+    scrollTopKey?: string | number;
+    autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
+}
+declare type InfiniteTablePropKeyboardNavigation = 'cell' | 'row' | false;
+declare type InfiniteTablePropKeyboardSelection = boolean;
+declare type InfiniteTablePropHeaderOptions = {
+    alwaysReserveSpaceForSortIcon: boolean;
 };
-declare type DataSourceFilterOperator<T> = {
-    name: string;
-    label?: string;
-    fn: DataSourceFilterOperatorFunction<T>;
+declare type InfiniteTablePropAutoSizeColumnsKey = string | number | {
+    key: string | number;
+    columnsToSkip?: string[];
+    columnsToResize?: string[];
+    includeHeader?: boolean;
 };
-declare type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
-declare type DataSourceFilterOperatorFunctionParam<T> = {
-    currentValue: any;
-    filterValue: any;
-    emptyValues: Set<any>;
-} & DataSourceFilterFunctionParam<T>;
-declare type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
-declare type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
-declare type DataSourceLivePaginationCursorParams<T> = {
-    array: T[];
-    lastItem: T | Partial<T> | null;
-    length: number;
+declare type Scrollbars = {
+    vertical: boolean;
+    horizontal: boolean;
 };
-declare type DataSourceLivePaginationCursorValue = string | number | null;
-interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
-}
-interface DataSourceDerivedState<T> {
-    operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
-    filterMode: NonUndefined<DataSourceProps<T>['filterMode']>;
-    multiSort: boolean;
-    controlledSort: boolean;
-    controlledFilter: boolean;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-    lazyLoadBatchSize?: number;
-}
-declare type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
-interface DataSourceContextValue<T> {
-    getState: () => DataSourceState<T>;
-    componentState: DataSourceState<T>;
-    componentActions: DataSourceComponentActions<T>;
-}
-declare enum DataSourceActionType {
-    INIT = "INIT"
-}
-interface DataSourceAction<T> {
-    type: DataSourceActionType;
-    payload: T;
-}
-interface DataSourceReducer<T> {
-    (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
-}
-
-declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParams<T, InfiniteTableComputedColumn<T>>;
-
-declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
-
-declare const InfiniteTableClassName: string;
-declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => JSX.Element)>;
-declare function InfiniteTable<T>(props: InfiniteTableProps<T>): JSX.Element;
-declare namespace InfiniteTable {
-    var defaultProps: {
-        rowHeight: number;
-        columnHeaderHeight: string;
-    };
-}
-
-declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
-
-declare function useDataSource<T>(): DataSourceState<T>;
+declare type ScrollAdjustPosition = 'start' | 'end' | 'center';
 
-declare function DataSource<T>(props: DataSourceProps<T>): JSX.Element;
+declare function debounce(fn: Function, { wait }: {
+    wait: number;
+}): (...args: any[]) => void;
 
 declare type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT> = {
     [propName in keyof TYPE_PROPS & keyof TYPE_RESULT]: 1 | ((value: TYPE_PROPS[propName]) => TYPE_RESULT[propName]);
@@ -1660,6 +1951,7 @@ declare type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT
     forwardProps?: (setupState: COMPONENT_SETUP_STATE) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE>;
     allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
     interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
+    mappedCallbacks?: ComponentMappedCallbacks<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
     onPropChange?: (params: {
         name: keyof T_PROPS;
         oldValue: any;
@@ -1670,6 +1962,7 @@ declare type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT
         state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>;
         oldState: null | (COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>);
         parentState: T_PARENT_STATE | null;
+        getState: () => COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
     }) => COMPONENT_DERIVED_STATE;
     concludeReducer?: (params: {
         previousState: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
@@ -1707,4 +2000,9 @@ declare const defaultFilterEditors: InfiniteTablePropFilterEditors<unknown>;
 declare function StringFilterEditor<T>(props: InfiniteTableFilterEditorProps<T>): JSX.Element;
 declare function NumberFilterEditor<T>(props: InfiniteTableFilterEditorProps<T>): JSX.Element;
 
-export { ColumnTypeWithInherit, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropLivePaginationCursor, DataSourcePropPivotBy, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableFilterEditorProps, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTableGroupColumnRenderIconFunction, InfiniteTableImperativeApi, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTablePropFilterEditors, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, NumberFilterEditor, Scrollbars, StringFilterEditor, debounce, defaultFilterEditors, defaultFilterTypes, defaultFilterTypes as filterTypes, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };
+declare const components: {
+    CheckBox: typeof InfiniteCheckBox;
+    LoadMask: (props: LoadMaskProps) => JSX.Element;
+};
+
+export { ColumnTypeWithInherit, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropPivotBy, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnsMap, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableFilterEditorProps, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropFilterEditors, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, NumberFilterEditor, RowSelectionState, Scrollbars, StringFilterEditor, components, debounce, defaultFilterEditors, defaultFilterTypes, defaultFilterTypes as filterTypes, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };