@infinite-table/infinite-react 7.4.2 → 7.5.0

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as React$1 from 'react';
-import React__default, { CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, KeyboardEvent, HTMLAttributes, ReactNode, EffectCallback, DependencyList } from 'react';
+import React__default, { RefCallback, CSSProperties, HTMLProps, MutableRefObject, MouseEvent, KeyboardEvent, HTMLAttributes, ReactNode, EffectCallback, DependencyList } from 'react';
 
 type ManagedComponentStateContextValue<T_STATE, T_ACTIONS> = {
     getComponentState: () => T_STATE;
@@ -542,7 +542,45 @@ declare function buildManagedComponent<T_PROPS extends object, COMPONENT_MAPPED_
 };
 declare function useManagedComponentState<COMPONENT_STATE>(Context?: React$1.Context<ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateActions<COMPONENT_STATE>>>): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
 
-type Renderable = React$1.ReactNode | React$1.JSX.Element;
+type PerfMarkerDetails = {
+    name: string;
+    value: string | number | boolean;
+}[];
+interface PerfMarker {
+    start(options?: {
+        details?: PerfMarkerDetails;
+    }): PerfMarker;
+    end(options?: {
+        details?: PerfMarkerDetails;
+    }): PerfMarker;
+}
+
+interface RowInfoStore<T> {
+    /**
+     * Update the entire dataArray (called from reducer)
+     * Compares old vs new rowInfo at each index and notifies subscribers for changed indices
+     */
+    notifyDataArray(newDataArray: InfiniteTableRowInfo<T>[], params?: {
+        marker?: PerfMarker;
+    }): void;
+    /**
+     * Get current rowInfo at index (snapshot for useSyncExternalStore)
+     */
+    getRowInfoAtIndex(index: number): InfiniteTableRowInfo<T> | undefined;
+    /**
+     * Subscribe to changes at a specific row index
+     * Returns unsubscribe function
+     */
+    subscribeToRowIndex(rowIndex: number, callback: () => void): () => void;
+    /**
+     * Get current dataArray (for components that need full array)
+     */
+    getDataArray(): InfiniteTableRowInfo<T>[];
+    /**
+     * Clear the store (reset dataArray and remove all subscribers)
+     */
+    clear(): void;
+}
 
 type TableRenderRange = {
     start: [number, number];
@@ -1014,2190 +1052,2184 @@ declare abstract class BooleanCollectionState<StateObject, KeyType> {
     protected toggleItem(key: KeyType): void;
 }
 
-type DiscriminatedUnion<A, B> = (A & {
-    [K in keyof B]?: undefined;
-}) | (B & {
-    [K in keyof A]?: undefined;
-});
-type KeyOfNoSymbol<T> = Exclude<keyof T, Symbol>;
-/**
- * Restrict using either exclusively the keys of T or exclusively the keys of U.
- *
- * No unique keys of T can be used simultaneously with any unique keys of U.
- *
- * @example
- *```
- * const myVar: XOR<T, U>
- *```
- *
- * @see https://github.com/maninak/ts-xor/tree/master#description
- */
-type XOR<T, U> = T | U extends object ? Prettify<Without<T, U> & U> | Prettify<Without<U, T> & T> : T | U;
-/**
- * Useful if applying XOR on more than 2 types.
- * It comes with the penalty of having the types wrapped in an array
- *
- * @example
- * ```
- * AllXOR<[
- *   { a: AModule },
- *   { b: BModule },
- *   { c: CModule },
- *   { d: DModule }
- * ]>
- * ```
- * @see https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-723571692
- */
-type AllXOR<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? AllXOR<[XOR<A, B>, ...Rest]> : never;
-/**
- * Get the keys of T without any keys of U.
- */
-type Without<T, U> = {
-    [P in Exclude<keyof T, keyof U>]?: never;
-};
-/**
- * Resolve mapped types and show the derived keys and their types when hovering in
- * IDEs, instead of just showing the names those mapped types are defined with.
- */
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
-type ValueGetterParams<T> = {
-    data: T;
-    field?: keyof T;
-};
-type GroupKeyType$1<T extends any = any> = T;
-type GroupByValueGetter<T> = (params: ValueGetterParams<T>) => any;
-type GroupBy<DataType, KeyType = any> = {
-    toKey?: (value: any, data: DataType) => GroupKeyType$1<KeyType>;
-    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
-} & AllXOR<[
-    {
-        field: KeyOfNoSymbol<DataType>;
-    },
-    {
-        valueGetter: GroupByValueGetter<DataType>;
-        field: KeyOfNoSymbol<DataType>;
-    },
-    {
-        valueGetter: GroupByValueGetter<DataType>;
-        field?: KeyOfNoSymbol<DataType>;
-        groupField: string;
-    }
-]>;
-
-type PerfMarkerDetails = {
-    name: string;
-    value: string | number | boolean;
-}[];
-interface PerfMarker {
-    start(options?: {
-        details?: PerfMarkerDetails;
-    }): PerfMarker;
-    end(options?: {
-        details?: PerfMarkerDetails;
-    }): PerfMarker;
+declare class RowDetailState<KeyType = any> extends BooleanCollectionState<RowDetailStateObject<KeyType>, KeyType> {
+    constructor(state: RowDetailStateObject<KeyType> | RowDetailState<KeyType>);
+    getState(): RowDetailStateObject<KeyType>;
+    getPositiveFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
+    getNegativeFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
+    areAllCollapsed(): boolean;
+    areAllExpanded(): boolean;
+    collapseAll(): void;
+    expandAll(): void;
+    isRowDetailsExpanded: (key: KeyType) => boolean;
+    isRowDetailsCollapsed(key: KeyType): boolean;
+    setRowDetailsExpanded(key: KeyType, shouldExpand: boolean): void;
+    collapseRowDetails(key: KeyType): void;
+    expandRowDetails(key: KeyType): void;
+    toggleRowDetails(key: KeyType): void;
 }
 
-type SortDir = 1 | -1;
-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 | 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;
+type Renderable = React$1.ReactNode | React$1.JSX.Element;
+
+type TableRenderCellFnParam = {
+    domRef: RefCallback<HTMLElement>;
+    rowIndex: number;
+    colIndex: number;
+    rowspan: number;
+    colspan: number;
+    hidden: boolean;
+    width: number;
+    height: number;
+    widthWithColspan: number;
+    heightWithRowspan: number;
+    rowFixed: FixedPosition;
+    colFixed: FixedPosition;
+    onMouseEnter: (event: React.MouseEvent<HTMLElement>) => void;
+    onMouseLeave: (event: React.MouseEvent<HTMLElement>) => void;
 };
-type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
-    field?: keyof T | (keyof T | ((item: T) => any))[];
+type TableRenderDetailRowFnParam = {
+    domRef: RefCallback<HTMLElement>;
+    rowIndex: number;
+    hidden: boolean;
+    height: number;
+    rowFixed: FixedPosition;
+    onMouseEnter: (event: React.MouseEvent<HTMLElement>) => void;
+    onMouseLeave: (event: React.MouseEvent<HTMLElement>) => void;
 };
-declare const multisort: {
-    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options?: {
-        marker?: PerfMarker;
-        get?: (item: any) => T;
-    } | ((item: any) => T)): T[];
-    knownTypes: {
-        [key: string]: (first: any, second: any) => number;
-    };
+type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
+type TableRenderDetailRowFn = (param: TableRenderDetailRowFnParam) => Renderable;
+type RenderRangeOptions = {
+    force?: boolean;
+    renderCell: TableRenderCellFn;
+    renderDetailRow?: TableRenderDetailRowFn;
+    onRender: (items: Renderable[]) => void;
 };
-type NestedMultiSortOptions<T> = {
-    get?: (item: any) => T;
-    nodesKey: string;
-    isLeafNode?: (item: T) => boolean;
-    getNodeChildren?: (item: T) => null | T[];
-    toKey: (item: T) => any;
-    depthFirst?: boolean;
-    inplace?: boolean;
-    marker?: PerfMarker;
+type HorizontalLayoutColVisibilityOptions = {
+    horizontalLayoutPageIndex?: number;
 };
-declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];
 
-type MenuIconProps = {
-    lineWidth?: number;
-    lineStyle?: React$1.CSSProperties;
-    style?: React$1.CSSProperties;
-    className?: string;
-    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
-    reserveSpaceWhenHidden?: boolean;
-    menuVisible?: boolean;
-    children?: React$1.ReactNode;
-};
-declare function MenuIcon(props: MenuIconProps): React$1.JSX.Element;
+interface GridCellInterface<T_ADDITIONAL_CELL_INFO = any> {
+    debugId: string;
+    update(content: Renderable, additionalInfo?: T_ADDITIONAL_CELL_INFO, scrollingObjectParam?: {
+        scrolling: boolean;
+    }): void;
+    getElement(): HTMLElement | null;
+    getNode(): Renderable;
+    destroy(): void;
+    onMount(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
+    getAdditionalInfo(): T_ADDITIONAL_CELL_INFO | undefined;
+    isMounted(): boolean;
+    ref: React.RefCallback<HTMLElement | undefined>;
+}
+
+type CellPos = [number, number];
+
+declare class GridCellManager<T_ADDITIONAL_CELL_INFO> extends Logger {
+    private matrix;
+    private rowsWithCellsHistory;
+    private columnsWithCellsHistory;
+    private cellToMatrixPosition;
+    private pool;
+    debugId: string;
+    private offRemoveCell;
+    constructor(debugId: string);
+    private onRemoveCell;
+    set poolSize(cellCount: number);
+    get poolSize(): number;
+    getDetachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    private clearCellFromMatrix;
+    private addCellToMatrix;
+    private setCellPositionInMatrix;
+    renderNodeAtCell(node: Renderable, cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, cellPos: CellPos, additionalInfo?: T_ADDITIONAL_CELL_INFO, scrollingObjectParam?: {
+        scrolling: boolean;
+        isHorizontalLayout: boolean;
+    }): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    getCellPosition(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): CellPos | null;
+    getCellAt(cellPos: CellPos): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    /**
+     * This gets a cell for a given position.
+     * If there's already a cell currently attached at that position, it will be returned.
+     *
+     * Otherwise, we try to return the most optimal cell to use for that position.
+     * If the optimise parameter is set to 'row', we will try to return a detached cell
+     * that was last rendered in that row.
+     *
+     * If the optimise parameter is set to 'column', we will try to return a detached cell
+     * that was last rendered in that column.
+     *
+     * @param cellPos [rowIndex, colIndex]
+     * @param optimise 'row' | 'column'
+     */
+    getCellFor(cellPos: CellPos, optimise: 'row' | 'column'): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    isCellAttached(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
+    isCellAttachedAt(cellPos: CellPos): boolean;
+    getMatrix(): Renderable[][];
+    getAllCells(): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
+    getCellsForRow(rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
+    getOneAttachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    getRowsWithCells(): number[];
+    getColumnsWithCells(): number[];
+    isRowAttached(rowIndex: number): boolean;
+    isColumnAttached(colIndex: number): boolean;
+    detachRow(rowIndex: number): void;
+    detachCol(colIndex: number): void;
+    detachCell(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
+    detachCells(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>): void;
+    detachRowsStartingWith(rowIndex: number): void;
+    detachColsStartingWith(colIndex: number): void;
+    detachCellsStartingAt(cellPos: CellPos): void;
+    detachCellAt(cellPos: CellPos): boolean;
+    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFn;
+    getCellsOutsideRenderRange: (range: TableRenderRange) => Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
+    getCellFromListForRow(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    getCellFromListForColumn(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, colIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    getCellCountInMatrix(): number;
+    destroy(): void;
+    reset(): void;
+    makeDetachedCellsEmpty(): void;
+    withDetachedCells(fn: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
+}
 
-type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
-type InfiniteTableToggleTreeNodeFn = (nodePath: any[]) => void;
-type InfiniteTableToggleRowDetailsFn = (id: any) => void;
-type InfiniteTableSelectRowFn = (id: any) => void;
-type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    dragging: boolean;
-    column: COL_TYPE;
-    columnsMap: Map<string, COL_TYPE>;
-    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
-    columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
-    selectionMode: DataSourcePropSelectionMode;
-    horizontalLayoutPageIndex: null | number;
-    allRowsSelected: boolean;
-    someRowsSelected: boolean;
-    filtered: boolean;
-    api: InfiniteTableApi<DATA_TYPE>;
-    dataSourceApi: DataSourceApi<DATA_TYPE>;
-    columnApi: InfiniteTableColumnApi<DATA_TYPE>;
-    renderBag: {
-        all?: Renderable;
-        header: string | number | Renderable;
-        sortIcon?: Renderable;
-        menuIcon?: Renderable;
-        menuIconProps?: MenuIconProps;
-        filterIcon?: Renderable;
-        filterEditor?: Renderable;
-        selectionCheckBox?: Renderable;
-    };
-} & ({
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
-    renderLocation: 'column-header';
-} | {
-    renderLocation: 'grouping-toolbar' | 'column-menu' | 'column-filter';
-});
-type InfiniteTableColumnRenderBag = {
-    value: string | number | Renderable;
-    groupIcon?: Renderable;
-    treeIcon?: Renderable;
-    rowDetailsIcon?: Renderable;
-    all?: Renderable;
-    selectionCheckBox?: Renderable;
-};
-type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
-    rowIndexInHorizontalLayoutPage: null | number;
-    horizontalLayoutPageIndex: null | number;
-    value: string | number | Renderable;
-    align: InfiniteTableColumnAlignValues;
-    verticalAlign: InfiniteTableColumnVerticalAlignValues;
-    renderBag: InfiniteTableColumnRenderBag;
-    rowIndex: number;
-    rowActive: boolean;
-    api: InfiniteTableApi<DATA_TYPE>;
-    dataSourceApi: DataSourceApi<DATA_TYPE>;
-    editError?: Error;
-    column: COL_TYPE;
-    columnsMap: Map<string, COL_TYPE>;
-    fieldsToColumn: Map<keyof DATA_TYPE, COL_TYPE>;
-    groupByColumn?: InfiniteTableComputedColumn<DATA_TYPE>;
-    toggleCurrentGroupRow: () => void;
-    toggleCurrentTreeNode: () => void;
-    expandTreeNode: InfiniteTableToggleTreeNodeFn;
-    collapseTreeNode: InfiniteTableToggleTreeNodeFn;
-    toggleGroupRow: InfiniteTableToggleGroupRowFn;
-    toggleTreeNode: InfiniteTableToggleTreeNodeFn;
-    toggleCurrentTreeNodeSelection: () => void;
-    toggleCurrentGroupRowSelection: () => void;
-    toggleCurrentRowSelection: () => void;
-    toggleCurrentRowDetails: () => void;
-    toggleRowDetails: InfiniteTableToggleRowDetailsFn;
-    expandRowDetails: InfiniteTableToggleRowDetailsFn;
-    collapseRowDetails: InfiniteTableToggleRowDetailsFn;
-    rowHasSelectedCells: boolean;
-    cellSelected: boolean;
-    selectCurrentRow: () => void;
-    selectRow: InfiniteTableSelectRowFn;
-    deselectRow: InfiniteTableSelectRowFn;
-    deselectCurrentRow: () => void;
-    selectCell: () => void;
-    deselectCell: () => void;
-    toggleRowSelection: InfiniteTableSelectRowFn;
-    toggleGroupRowSelection: InfiniteTableToggleGroupRowFn;
-    toggleTreeNodeSelection: InfiniteTableToggleTreeNodeFn;
-    selectTreeNode: InfiniteTableToggleTreeNodeFn;
-    deselectTreeNode: InfiniteTableToggleTreeNodeFn;
-    selectionMode: DataSourcePropSelectionMode | undefined;
-    rootGroupBy: DataSourceState<DATA_TYPE>['groupBy'];
-    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
-};
-type InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
-type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE>;
-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;
-};
-type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
-    isGroupRow: true;
-}) => Renderable | null;
-type InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
-    isTreeNode: true;
-    isParentNode: true;
-}) => Renderable | null;
-type InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
-    isTreeNode: true;
-    isParentNode: false;
-}) => Renderable | null;
-type InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, EXTRA_NODE_PARAMS = Partial<InfiniteTableRowInfoDataDiscriminator_ParentNode<DATA_TYPE> | InfiniteTableRowInfoDataDiscriminator_LeafNode<DATA_TYPE>>, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & EXTRA_NODE_PARAMS) => Renderable | null;
-type InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
-    isGroupRow: false;
-}) => Renderable | null;
-type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE>) => Renderable | null;
-type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
-type InfiniteTableColumnOrHeaderRenderFunction<T> = (params: (InfiniteTableColumnCellContextType<T> & {
-    rowInfo: InfiniteTableRowInfo<T>;
-}) | (InfiniteTableColumnHeaderParam<T> & {
-    rowInfo: null;
-})) => ReturnType<InfiniteTableColumnRenderFunction<T>>;
-type InfiniteTableColumnContentFocusable<T> = boolean | InfiniteTableColumnContentFocusableFn<T>;
-type InfiniteTableColumnEditable<T> = boolean | InfiniteTableColumnEditableFn<T>;
-type InfiniteTableColumnContentFocusableFn<T> = (params: InfiniteTableColumnContentFocusableParams<T>) => boolean;
-type InfiniteTableColumnEditableFn<T> = (params: InfiniteTableColumnEditableParams<T>) => boolean | Promise<boolean>;
-type InfiniteTableColumnContentFocusableParams<T> = InfiniteTableRowInfoDataDiscriminatorWithColumnAndApis<T>;
-type InfiniteTableColumnEditableParams<T> = InfiniteTableColumnContentFocusableParams<T>;
-type InfiniteTableColumnGetValueToPersistParams<T> = InfiniteTableColumnEditableParams<T> & {
-    initialValue: any;
-};
-type InfiniteTableColumnAlignValues = 'start' | 'center' | 'end';
-type InfiniteTableColumnVerticalAlignValues = 'start' | 'center' | 'end';
-type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
-type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
-type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
-type InfiniteTableColumnStylingFnParams<T> = {
-    value: Renderable;
-    column: InfiniteTableComputedColumn<T>;
-    rowIndexInHorizontalLayoutPage: null | number;
-    horizontalLayoutPageIndex: null | number;
-    inEdit: boolean;
-    rowHasSelectedCells: boolean;
-    editError: InfiniteTableColumnRenderParamBase<T>['editError'];
-} & InfiniteTableRowInfoDataDiscriminator<T>;
-type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStylingFnParams<T>) => undefined | React$1.CSSProperties;
-type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
-type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React$1.CSSProperties;
-type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStylingFnParams<T>) => undefined | string;
-type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
-type InfiniteTableColumnAlign<T> = InfiniteTableColumnAlignValues | InfiniteTableColumnAlignFn<T>;
-type InfiniteTableColumnVerticalAlign<T> = InfiniteTableColumnVerticalAlignValues | InfiniteTableColumnVerticalAlignFn<T>;
-type InfiniteTableColumnAlignFn<T> = (params: InfiniteTableColumnAlignFnParams<T>) => InfiniteTableColumnAlignValues;
-type InfiniteTableColumnAlignFnParams<T> = XOR<{
-    isHeader: true;
-    column: InfiniteTableComputedColumn<T>;
-}, InfiniteTableColumnStylingFnParams<T> & {
-    isHeader: false;
-}>;
-type InfiniteTableColumnVerticalAlignFn<T> = (params: InfiniteTableColumnAlignFnParams<T>) => InfiniteTableColumnVerticalAlignValues;
-type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
-type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
-type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
-type InfiniteTableColumnValueGetterParams<T> = ValueGetterParams<T>;
-type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
-type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
-type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
-type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
-type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
-type InfiniteTableColumnSortableFn<T> = (context: {
-    api: InfiniteTableApi<T>;
-    columnApi: InfiniteTableColumnApi<T>;
-    column: InfiniteTableComputedColumn<T>;
-    columns: Map<string, InfiniteTableComputedColumn<T>>;
-}) => boolean;
-type InfiniteTableColumnSortable<T> = boolean | InfiniteTableColumnSortableFn<T>;
 /**
- * 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`.
+ * This is only used for rendering Detail rows in a master-detail DataGrid
  */
-type InfiniteTableColumn<DATA_TYPE> = {
-    field?: KeyOfNoSymbol<DATA_TYPE>;
-    valueGetter?: InfiniteTableColumnValueGetter<DATA_TYPE>;
-    defaultSortable?: InfiniteTableColumnSortable<DATA_TYPE>;
+interface ListRowInterface {
+    debugId: string;
+    update(content: Renderable): void;
+    getElement(): HTMLElement | null;
+    getNode(): Renderable;
+    destroy(): void;
+    onMount(callback: (row: ListRowInterface) => void): void;
+    isMounted(): boolean;
+    ref: (htmlElement: HTMLElement) => void;
+}
+
+declare class ListRowManager extends Logger {
+    private pool;
+    private indexToRow;
+    private rowToIndex;
+    debugId: string;
+    private offRemoveRow;
+    constructor(debugId: string);
+    private onRemoveRow;
+    set poolSize(rowCount: number);
+    get poolSize(): number;
+    getDetachedRow(): ListRowInterface;
     /**
-     * Whether the column is draggable by default.
+     * This gets a row for a given position.
+     * If there's already a row currently attached at that position, it will be returned.
      *
-     * This prop overrides the top-level columnDefaultDraggable prop, but is
-     * overridden by the top-level draggableColumns prop.
+     * Otherwise, we return another row.
+     * @param rowIndex
      */
-    defaultDraggable?: boolean;
-    resizable?: boolean;
-    shouldAcceptEdit?: (params: InfiniteTablePropOnEditAcceptedParams<DATA_TYPE>) => boolean | Error | Promise<boolean | Error>;
-    contentFocusable?: InfiniteTableColumnContentFocusable<DATA_TYPE>;
-    defaultEditable?: InfiniteTableColumnEditable<DATA_TYPE>;
-    getValueToEdit?: (params: InfiniteTableColumnEditableParams<DATA_TYPE>) => any | Promise<any>;
-    getValueToPersist?: (params: InfiniteTableColumnGetValueToPersistParams<DATA_TYPE>) => any | Promise<any>;
-    comparer?: InfiniteTableColumnComparer<DATA_TYPE>;
-    defaultHiddenWhenGroupedBy?: '*' | true | keyof DATA_TYPE | {
-        [k in keyof Partial<DATA_TYPE>]: true;
-    };
-    align?: InfiniteTableColumnAlign<DATA_TYPE>;
-    headerAlign?: InfiniteTableColumnAlign<DATA_TYPE>;
-    verticalAlign?: InfiniteTableColumnVerticalAlign<DATA_TYPE>;
-    columnGroup?: string;
-    header?: InfiniteTableColumnHeader<DATA_TYPE>;
-    renderHeader?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
-    name?: Renderable;
-    cssEllipsis?: boolean;
-    headerCssEllipsis?: boolean;
-    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
-    dataType?: InfiniteTableDataTypeNames;
-    sortType?: string | string[];
-    filterType?: string;
-    style?: InfiniteTableColumnStyle<DATA_TYPE>;
-    headerStyle?: InfiniteTableColumnHeaderStyle<DATA_TYPE>;
-    headerClassName?: InfiniteTableColumnHeaderClassName<DATA_TYPE>;
-    className?: InfiniteTableColumnClassName<DATA_TYPE>;
-    rowspan?: InfiniteTableColumnRowspanFn<DATA_TYPE>;
-    render?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
-    renderValue?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
-    renderGroupValue?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
-    renderLeafValue?: InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE>;
-    valueFormatter?: InfiniteTableColumnValueFormatter<DATA_TYPE, Renderable>;
-    defaultWidth?: number;
-    defaultFlex?: number;
-    defaultFilterable?: boolean;
-    defaultGroupable?: boolean;
-    minWidth?: number;
-    maxWidth?: number;
-    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
-    renderRowDetailIcon?: boolean | InfiniteTableColumnRenderFunction<DATA_TYPE>;
-    renderTreeIcon?: boolean | InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, {
-        isTreeNode: true;
-        isParentNode: boolean;
-        isGroupRow: false;
-        nodeExpanded: boolean;
-    }>;
-    renderTreeIconForParentNode?: InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, {
-        isTreeNode: true;
-        isGroupRow: true;
-        isParentNode: true;
-    }>;
-    renderTreeIconForLeafNode?: InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, {
-        isTreeNode: true;
-        isGroupRow: false;
-        isLeafNode: true;
+    getRowFor(rowIndex: number): ListRowInterface;
+    private setRowIndexInList;
+    detachStartingWith(rowIndex: number): void;
+    getRowAt(rowPos: number): ListRowInterface | undefined;
+    getRowIndex(row: ListRowInterface): number | undefined;
+    isRowAttached(row: ListRowInterface): boolean;
+    isRowAttachedAt(rowIndex: number): boolean;
+    getList(): Renderable[];
+    getAttachedCount(): number;
+    forEachAttachedRow(fn: (row: ListRowInterface) => void): void;
+    getAttachedIndexes(): number[];
+    getAllRows(): ListRowInterface[];
+    detachRowAt(rowIndex: number): void;
+    detachRow(row: ListRowInterface): void;
+    renderNodeAtRow(node: Renderable, row: ListRowInterface, rowIndex: number): ListRowInterface;
+    makeDetachedRowsEmpty(): void;
+    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFn;
+    withDetachedRows(fn: (row: ListRowInterface) => void): void;
+    destroy(): void;
+    reset(): void;
+}
+
+declare class GridRenderer extends Logger {
+    protected brain: MatrixBrain;
+    debugId: string;
+    protected destroyed: boolean;
+    private scrolling;
+    cellHoverClassNames: string[];
+    cellDetachedClassNames: string[];
+    cellManager: GridCellManager<{
+        renderRowIndex: number;
+        renderColIndex: number;
     }>;
-    renderSortIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
-    renderFilterIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
-    renderSelectionCheckBox?: boolean | InfiniteTableColumnOrHeaderRenderFunction<DATA_TYPE>;
-    renderMenuIcon?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
-    renderHeaderSelectionCheckBox?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
-    components?: {
-        ColumnCell?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
-        HeaderCell?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
-        Editor?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
-        FilterEditor?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
-        FilterOperatorSwitch?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
-        MenuIcon?: React$1.ComponentType<MenuIconProps>;
+    protected rowManager: ListRowManager;
+    private lastEnteredRow;
+    private lastExitedRow;
+    private onDestroy;
+    private hoverRowUpdatesInProgress;
+    private infiniteNode;
+    private getInfiniteNode;
+    setDetailTransform: (element: HTMLElement, _rowIndex: number, { y, scrollTop, scrollLeft, }: {
+        y: number;
+        scrollTop?: boolean;
+        scrollLeft?: number;
+    }) => void;
+    setTransform: (element: HTMLElement, _rowIndex: number, colIndex: number, { x, y, scrollLeft, scrollTop, }: {
+        x: number;
+        y: number;
+        scrollLeft?: boolean;
+        scrollTop?: boolean;
+    }, zIndex: number | "auto" | undefined | null) => void;
+    constructor(brain: MatrixBrain, debugId?: string);
+    private onCellAttached;
+    private onCellDetached;
+    private onRowAttached;
+    private onRowDetached;
+    getFullyVisibleRowsRange: () => {
+        start: number;
+        end: number;
+    } | null;
+    getScrollPositionForScrollRowIntoView: (rowIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+        colIndex?: number;
+    }) => ScrollPosition | null;
+    getScrollPositionForScrollColumnIntoView: (colIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    } & HorizontalLayoutColVisibilityOptions) => ScrollPosition | null;
+    getScrollPositionForScrollCellIntoView: (rowIndex: number, colIndex: number, config?: {
+        rowScrollAdjustPosition?: ScrollAdjustPosition;
+        colScrollAdjustPosition?: ScrollAdjustPosition;
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offsetTop: number;
+        offsetLeft: number;
+    }) => ScrollPosition | null;
+    isRowFullyVisible: (rowIndex: number, offsetMargin?: number) => boolean;
+    isRowVisible: (rowIndex: number, offsetMargin?: number) => boolean;
+    isRowRendered: (rowIndex: number) => boolean;
+    isCellVisible: (rowIndex: number, colIndex: number) => boolean;
+    isCellFullyVisible: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isColumnFullyVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isColumnVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isCellRendered: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isColumnRendered: (colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    getExtraSpanCellsForRange: (range: TableRenderRange) => [number, number][];
+    isCellRenderedAndMappedCorrectly(row: number, col: number): {
+        rendered: boolean;
+        mapped: boolean;
     };
+    renderRange(range: TableRenderRange, { renderCell, renderDetailRow, force, onRender }: RenderRangeOptions): Renderable[];
+    getFixedRanges: (currentRenderRange: TableRenderRange) => TableRenderRange[];
+    protected isCellFixed: (rowIndex: number, colIndex: number) => {
+        row: FixedPosition;
+        col: FixedPosition;
+    };
+    protected isCellCovered: (rowIndex: number, colIndex: number) => false | number[];
+    private renderDetailRowAtElement;
+    protected getCellRealCoordinates(rowIndex: number, colIndex: number): {
+        rowIndex: number;
+        colIndex: number;
+    };
+    protected onMouseEnterNotBound: (event: React.MouseEvent<HTMLElement>) => void;
+    protected onMouseLeaveNotBound: (event: React.MouseEvent<HTMLElement>) => void;
+    protected renderCellAt(rowIndex: number, colIndex: number, cell: GridCellInterface, renderCell: TableRenderCellFn): void;
+    protected onMouseEnter: (rowIndex: number) => void;
+    private addHoverClass;
+    protected onMouseLeave: (rowIndex: number) => void;
+    private removeHoverClass;
+    protected updateHoverClassNamesForRow: (rowIndex: number) => void;
+    protected updateElementPosition: (cell: GridCellInterface<{
+        renderRowIndex: number;
+        renderColIndex: number;
+    }>, options?: {
+        hidden: boolean;
+        rowspan: number;
+        colspan: number;
+    }) => void;
+    private updateDetailElementPosition;
+    private onScrollStart;
+    private onScrollStop;
+    adjustFixedElementsOnScroll: (scrollPosition?: ScrollPosition) => void;
+    destroy: () => void;
+    reset(): void;
+}
+
+type CellPositionByIndex = {
+    rowIndex: number;
+    colIndex: number;
 };
-type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'defaultSortable'> & {
-    groupByForColumn: GroupBy<T> | GroupBy<T>[];
-    id?: string;
-};
-type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
-type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotTotalColumnGroup?: true;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex: PivotBy<DataType, KeyType>;
-    pivotGroupKey: KeyType;
-    pivotIndex: number;
-};
-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;
-};
-type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
-type InfiniteTableComputedColumnBase<T> = {
-    computedFilterType: string;
-    computedSortType: string | string[];
-    computedDataType: string;
-    computedWidth: number;
-    computedFlex: number | null;
-    computedMinWidth: number;
-    computedMaxWidth: number;
-    computedOffset: number;
-    computedPinningOffset: number;
-    computedAbsoluteOffset: number;
-    computedSortInfo: DataSourceSingleSortInfo<T> | null;
-    computedSorted: boolean;
-    computedSortedAsc: boolean;
-    computedSortedDesc: boolean;
-    computedSortIndex: number;
-    computedVisible: boolean;
-    computedVisibleIndex: number;
-    computedVisibleIndexInCategory: number;
-    computedMultiSort: boolean;
-    computedFiltered: boolean;
-    computedFilterable: boolean;
-    computedGroupedBy: boolean;
-    computedGroupedByIndex: number | undefined;
-    computedGroupable: boolean;
-    computedFilterValue: DataSourceFilterValueItem<T> | null;
-    computedPinned: InfiniteTableColumnPinnedValues;
-    computedDraggable: boolean;
-    computedResizable: boolean;
-    computedFirstInCategory: boolean;
-    computedLastInCategory: boolean;
-    computedFirst: boolean;
-    computedLast: boolean;
-    computedEditable: NonUndefined<InfiniteTableColumn<T>['defaultEditable']>;
-    computedSortable: NonUndefined<InfiniteTableColumn<T>['defaultSortable']>;
-    colType: InfiniteTableColumnType<T>;
-    id: string;
+type MultiSelectRangeOptions = {
+    horizontalLayout: false;
+} | {
+    horizontalLayout: true;
+    rowsPerPage: number;
+    columnsPerSet: number;
 };
-type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
-type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 
-type ForceOptions = {
-    force?: boolean;
-};
-type TreeExpandStateApi<T> = {
-    isNodeExpanded(nodePath: any[]): boolean;
-    isNodeReadOnly(nodePath: any[]): boolean;
-    expandNode(nodePath: any[], options?: ForceOptions): void;
-    collapseNode(nodePath: any[], options?: ForceOptions): void;
-    toggleNode(nodePath: any[], options?: ForceOptions): void;
-    getNodeDataByPath(nodePath: any[]): T | null;
-    getRowInfoByPath(nodePath: any[]): InfiniteTableRowInfo<T> | null;
-};
-type TreeSelectionApi<T = any> = {
-    get allRowsSelected(): boolean;
-    isNodeSelected(nodePath: NodePath$1): boolean | null;
-    selectNode(nodePath: NodePath$1, options?: ForceOptions): void;
-    setNodeSelection(nodePath: NodePath$1, selected: boolean, options?: ForceOptions): void;
-    deselectNode(nodePath: NodePath$1, options?: ForceOptions): void;
-    toggleNodeSelection(nodePath: NodePath$1, options?: ForceOptions): void;
-    selectAll(): void;
-    expandAll(): void;
-    collapseAll(): void;
-    deselectAll(): void;
-    getSelectedLeafNodePaths(config?: {
-        rootNodePath?: NodePath$1;
-        treeSelectionState?: TreeSelectionState<T>;
-    }): NodePath$1[];
-    getDeselectedLeafNodePaths(config?: {
-        rootNodePath?: NodePath$1;
-        treeSelectionState?: TreeSelectionState<T>;
-    }): NodePath$1[];
-    getSelectedLeafRowInfos(config?: {
-        rootNodePath?: NodePath$1;
-        treeSelectionState?: TreeSelectionState<T>;
-    }): InfiniteTable_Tree_RowInfoLeafNode<T>[];
-};
-type TreeApi<T> = TreeExpandStateApi<T> & TreeSelectionApi<T>;
-
-type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
-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 ScrollListener {
+    private scrollPosition;
+    private onScrollFns;
+    getScrollPosition: () => ScrollPosition;
+    onScroll: (fn: OnScrollFn) => () => void;
+    setScrollPosition: (scrollPosition: ScrollPosition) => void;
+    private notifyScrollChange;
+    destroy: () => void;
 }
 
-type IndexerOptions<DataType, PrimaryKeyType> = {
-    toPrimaryKey: (data: DataType) => PrimaryKeyType;
-    cache?: DataSourceCache<DataType, PrimaryKeyType>;
-    getNodeChildren?: TreeParams<DataType, PrimaryKeyType>['getNodeChildren'];
-    isLeafNode?: TreeParams<DataType, PrimaryKeyType>['isLeafNode'];
-    nodesKey: string | undefined;
+type DiscriminatedUnion<A, B> = (A & {
+    [K in keyof B]?: undefined;
+}) | (B & {
+    [K in keyof A]?: undefined;
+});
+type KeyOfNoSymbol<T> = Exclude<keyof T, Symbol>;
+/**
+ * Restrict using either exclusively the keys of T or exclusively the keys of U.
+ *
+ * No unique keys of T can be used simultaneously with any unique keys of U.
+ *
+ * @example
+ *```
+ * const myVar: XOR<T, U>
+ *```
+ *
+ * @see https://github.com/maninak/ts-xor/tree/master#description
+ */
+type XOR<T, U> = T | U extends object ? Prettify<Without<T, U> & U> | Prettify<Without<U, T> & T> : T | U;
+/**
+ * Useful if applying XOR on more than 2 types.
+ * It comes with the penalty of having the types wrapped in an array
+ *
+ * @example
+ * ```
+ * AllXOR<[
+ *   { a: AModule },
+ *   { b: BModule },
+ *   { c: CModule },
+ *   { d: DModule }
+ * ]>
+ * ```
+ * @see https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-723571692
+ */
+type AllXOR<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? AllXOR<[XOR<A, B>, ...Rest]> : never;
+/**
+ * Get the keys of T without any keys of U.
+ */
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
 };
-declare class Indexer<DataType, PrimaryKeyType = string> {
-    primaryKeyToData: Map<PrimaryKeyType, DataType>;
-    nodePathsToData: DeepMap<PrimaryKeyType, DataType>;
-    private removeNodePath;
-    private remove;
-    private add;
-    private addNodePath;
-    clear: () => void;
-    getDataForPrimaryKey: (primaryKey: PrimaryKeyType) => DataType | undefined;
-    getDataForNodePath: (nodePath: NodePath$1) => DataType | undefined;
-    indexArray: (arr: DataType[], options: IndexerOptions<DataType, PrimaryKeyType>) => DataType[];
-}
+/**
+ * Resolve mapped types and show the derived keys and their types when hovering in
+ * IDEs, instead of just showing the names those mapped types are defined with.
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 
-declare class RowDisabledState<KeyType = any> extends BooleanCollectionState<RowDisabledStateObject<KeyType>, KeyType> {
-    constructor(state: RowDisabledStateObject<KeyType> | RowDisabledState<KeyType>);
-    getState(): RowDisabledStateObject<KeyType>;
-    getPositiveFromState(state: RowDisabledStateObject<KeyType>): true | KeyType[];
-    getNegativeFromState(state: RowDisabledStateObject<KeyType>): true | KeyType[];
-    areAllDisabled(): boolean;
-    areAllEnabled(): boolean;
-    disableAll(): void;
-    enableAll(): void;
-    isRowEnabled: (key: KeyType) => boolean;
-    isRowDisabled(key: KeyType): boolean;
-    setRowEnabled(key: KeyType, enabled: boolean): void;
-    disableRow(key: KeyType): void;
-    enableRow(key: KeyType): void;
-    toggleRow(key: KeyType): void;
-}
+type MenuIconProps = {
+    lineWidth?: number;
+    lineStyle?: React$1.CSSProperties;
+    style?: React$1.CSSProperties;
+    className?: string;
+    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
+    reserveSpaceWhenHidden?: boolean;
+    menuVisible?: boolean;
+    children?: React$1.ReactNode;
+};
+declare function MenuIcon(props: MenuIconProps): React$1.JSX.Element;
 
-type RowSelectionStateItem = (any | any[])[];
-type RowSelectionStateObject = {
-    selectedRows: RowSelectionStateItem;
-    deselectedRows: RowSelectionStateItem;
-    defaultSelection: boolean;
-} | {
-    defaultSelection: true;
-    deselectedRows: RowSelectionStateItem;
-    selectedRows?: RowSelectionStateItem;
+type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
+type InfiniteTableToggleTreeNodeFn = (nodePath: any[]) => void;
+type InfiniteTableToggleRowDetailsFn = (id: any) => void;
+type InfiniteTableSelectRowFn = (id: any) => void;
+type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    dragging: boolean;
+    column: COL_TYPE;
+    columnsMap: Map<string, COL_TYPE>;
+    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
+    columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
+    selectionMode: DataSourcePropSelectionMode;
+    horizontalLayoutPageIndex: null | number;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    filtered: boolean;
+    api: InfiniteTableApi<DATA_TYPE>;
+    dataSourceApi: DataSourceApi<DATA_TYPE>;
+    columnApi: InfiniteTableColumnApi<DATA_TYPE>;
+    renderBag: {
+        all?: Renderable;
+        header: string | number | Renderable;
+        sortIcon?: Renderable;
+        menuIcon?: Renderable;
+        menuIconProps?: MenuIconProps;
+        filterIcon?: Renderable;
+        filterEditor?: Renderable;
+        selectionCheckBox?: Renderable;
+    };
+} & ({
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
+    renderLocation: 'column-header';
 } | {
-    defaultSelection: false;
-    selectedRows: RowSelectionStateItem;
-    deselectedRows?: RowSelectionStateItem;
-};
-type RowSelectionStateConfig<T> = {
-    groupBy: DataSourceState<T>['groupBy'];
-    groupDeepMap: DataSourceState<T>['groupDeepMap'];
-    toPrimaryKey: DataSourceState<T>['toPrimaryKey'];
-    totalCount: number;
-    indexer: DataSourceState<T>['indexer'];
-    lazyLoad: boolean;
-    onlyUsePrimaryKeys: boolean;
-};
-type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
-type RowSelectionStateOverride = {
-    getGroupKeysForPrimaryKey: RowSelectionState<any>['getGroupKeysForPrimaryKey'];
-    getGroupByLength: RowSelectionState<any>['getGroupByLength'];
-    getGroupCount: RowSelectionState<any>['getGroupCount'];
-    getGroupKeysDirectlyInsideGroup: RowSelectionState<any>['getGroupKeysDirectlyInsideGroup'];
-    getAllPrimaryKeysInsideGroup: RowSelectionState<any>['getAllPrimaryKeysInsideGroup'];
+    renderLocation: 'grouping-toolbar' | 'column-menu' | 'column-filter';
+});
+type InfiniteTableColumnRenderBag = {
+    value: string | number | Renderable;
+    groupIcon?: Renderable;
+    treeIcon?: Renderable;
+    rowDetailsIcon?: Renderable;
+    all?: Renderable;
+    selectionCheckBox?: Renderable;
 };
-declare class RowSelectionState<T = any> {
-    selectedRows: RowSelectionStateItem | null;
-    deselectedRows: RowSelectionStateItem | null;
-    defaultSelection: boolean;
-    selectedMap: DeepMap<any, true>;
-    deselectedMap: DeepMap<any, true>;
-    onlyUsePrimaryKeys: boolean;
-    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[][];
-    getAllPrimaryKeysInsideGroup(groupKeys: any[]): any[];
-    getGroupByLength(): number;
-    static from<T>(rowSeleStateObject: RowSelectionStateObject, getConfig: GetRowSelectionStateConfig<T>, overrides?: RowSelectionStateOverride): RowSelectionState<T>;
-    constructor(state: RowSelectionStateObject | RowSelectionState, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverride);
-    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 const DS_ERROR_CODES: Record<"DS001", DebugWarningPayload>;
-declare const INFINITE_ERROR_CODES: Record<"CSS001_CSS", DebugWarningPayload>;
-declare const ERROR_CODES: {
-    CSS001_CSS: DebugWarningPayload;
-    DS001: DebugWarningPayload;
-};
-
-type DevToolsMessageAddress = 'infinite-table-devtools-contentscript' | 'infinite-table-devtools-contentscript-panel' | 'infinite-table-devtools-background' | 'infinite-table-page';
-type DevToolsGenericMessage = {
-    source: DevToolsMessageAddress;
-    target: DevToolsMessageAddress;
-    payload: any;
-    type: string;
-};
-type ErrorCodeKey = keyof typeof ERROR_CODES;
-type DataSourceDebugWarningKey = keyof typeof DS_ERROR_CODES;
-type InfiniteTableDebugWarningKey = keyof typeof INFINITE_ERROR_CODES;
-type DebugWarningPayload = {
-    message: string;
-    code: ErrorCodeKey;
-    type: 'error' | 'warning';
-    status?: 'new' | 'discarded';
-    debugId?: string;
-};
-type DevToolsHookFnOptions = {
-    getState: () => InfiniteTableState<any>;
-    getDataSourceState: () => DataSourceState<any>;
-    getComputed: () => InfiniteTableComputedValues<any>;
-    actions: InfiniteTableActions<any>;
-    dataSourceActions: DataSourceComponentActions<any>;
-    api: InfiniteTableApi<any>;
-    dataSourceApi: DataSourceApi<any>;
-};
-type DevToolsOverrides = Partial<DevToolsInfiniteOverrides & DevToolsDataSourceOverrides>;
-type DevToolsInfiniteOverrides = Partial<{
-    groupRenderStrategy: InfiniteTableState<any>['groupRenderStrategy'];
-    columnVisibility: InfiniteTableState<any>['columnVisibility'];
-}>;
-type DevToolsDataSourceOverrides = Partial<{
-    groupBy: DataSourceState<any>['groupBy'];
-    sortInfo: DataSourceState<any>['sortInfo'];
-    multiSort: DataSourceState<any>['multiSort'];
-}>;
-type DevToolsHostPageMessagePayload = {
-    debugId: string;
-    columnOrder: string[];
-    visibleColumnIds: string[];
-    columnVisibility: InfiniteTableState<any>['columnVisibility'];
-    columns: Record<string, {
-        field: InfiniteTableComputedColumn<any>['field'];
-        dataType: InfiniteTableComputedColumn<any>['computedDataType'];
-        sortType: InfiniteTableComputedColumn<any>['computedSortType'];
-        filtered: InfiniteTableComputedColumn<any>['computedFiltered'];
-        sorted: InfiniteTableComputedColumn<any>['computedSorted'];
-        width: InfiniteTableComputedColumn<any>['computedWidth'];
-    }>;
-    groupRenderStrategy: InfiniteTableState<any>['groupRenderStrategy'];
-    groupBy: string[];
-    sortInfo: {
-        field: string;
-        dir: 1 | -1;
-        type?: string;
-    }[];
-    multiSort: DataSourceState<any>['multiSort'];
-    selectionMode: DataSourceState<any>['selectionMode'];
-    devToolsDetected: InfiniteTableState<any>['devToolsDetected'];
-    debugTimings: Record<DebugTimingKey, number>;
-    debugWarnings: Record<ErrorCodeKey, DebugWarningPayload>;
-};
-type DevToolsHostPageMessageType = 'update' | 'unmount' | 'log';
-type DevToolsHostPageLogMessage = {
-    type: Extract<DevToolsHostPageMessageType, 'log'>;
-    payload: DevToolsHostPageLogMessagePayload;
-};
-type DevToolsHostPageLogMessagePayload = {
-    channel: string;
-    color: string;
-    args: any[];
-    timestamp: number;
-    debugId?: string;
-};
-type DevToolsHostPageMessage = {
-    source: Extract<DevToolsMessageAddress, 'infinite-table-page'>;
-    target: Extract<DevToolsMessageAddress, 'infinite-table-devtools-background'>;
-    url: string;
-} & ({
-    type: Extract<DevToolsHostPageMessageType, 'update'>;
-    payload: DevToolsHostPageMessagePayload;
-} | {
-    type: Extract<DevToolsHostPageMessageType, 'unmount'>;
-    payload: {
-        debugId: string;
-    };
-} | DevToolsHostPageLogMessage);
-type DevToolsHookFn = (debugId: string, options: null | DevToolsHookFnOptions) => void;
-
-interface DataSourceDataParams<T> {
-    originalDataArray: T[];
-    masterRowInfo?: InfiniteTableRowInfo<any>;
-    sortInfo?: DataSourceSortInfo<T>;
-    groupBy?: DataSourcePropGroupBy<T>;
-    pivotBy?: DataSourcePropPivotBy<T>;
-    filterValue?: DataSourcePropFilterValue<T>;
-    refetchKey?: DataSourceProps<T>['refetchKey'];
-    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
-    lazyLoadBatchSize?: number;
-    lazyLoadStartIndex?: number;
-    groupKeys?: any[];
-    append?: boolean;
-    aggregationReducers?: DataSourcePropAggregationReducers<T>;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-    __cursorId?: DataSourceSetupState<T>['cursorId'];
-    changes?: DataSourceDataParamsChanges<T>;
-}
-type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
-type DataSourceSingleSortInfo<T> = MultisortInfoAllowMultipleFields<T> & {
-    id?: string;
-};
-type DataSourceGroupBy<T> = GroupBy<T, any>;
-type DataSourcePivotBy<T> = PivotBy<T, any>;
-type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
-type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
-type DataSourceRemoteData<T> = {
-    data: T[] | LazyGroupDataItem<T>[];
-    mappings?: DataSourceMappings;
-    cache?: boolean;
-    error?: string;
-    totalCount?: number;
-    totalCountUnfiltered?: number;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-};
-type DataSourceDataFn<T> = (dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>;
-type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | DataSourceDataFn<T>;
-type DataSourceGroupRowsList<KeyType = any> = true | KeyType[][];
-type DataSourcePropGroupRowsStateObject<KeyType = any> = {
-    expandedRows: DataSourceGroupRowsList<KeyType>;
-    collapsedRows: DataSourceGroupRowsList<KeyType>;
-};
-type DataSourcePropGroupRowsState<KeyType = any> = GroupRowsState<KeyType> | DataSourcePropGroupRowsStateObject<KeyType>;
-type RowDetailStateObject<KeyType = any> = {
-    expandedRows: true | KeyType[];
-    collapsedRows: true | KeyType[];
-};
-type RowDisabledStateObject<KeyType = any> = {
-    enabledRows: true;
-    disabledRows: KeyType[];
-} | {
-    disabledRows: true;
-    enabledRows: KeyType[];
-};
-type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
-type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
-interface DataSourceMappedState<T> {
-    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
-    livePagination: DataSourceProps<T>['livePagination'];
-    refetchKey: NonUndefined<DataSourceProps<T>['refetchKey']>;
-    isRowSelected: DataSourceProps<T>['isRowSelected'];
-    isNodeSelected: TreeDataSourceProps<T>['isNodeSelected'];
-    isNodeExpanded: TreeDataSourceProps<T>['isNodeExpanded'];
-    isNodeCollapsed: TreeDataSourceProps<T>['isNodeCollapsed'];
-    isNodeReadOnly: NonUndefined<TreeDataSourceProps<T>['isNodeReadOnly']>;
-    isNodeSelectable: NonUndefined<TreeDataSourceProps<T>['isNodeSelectable']>;
-    onNodeCollapse: TreeDataSourceProps<T>['onNodeCollapse'];
-    onNodeExpand: TreeDataSourceProps<T>['onNodeExpand'];
-    isRowDisabled: DataSourceProps<T>['isRowDisabled'];
-    nodesKey: NonUndefined<TreeDataSourceProps<T>['nodesKey']>;
-    treeSelection: TreeDataSourceProps<T>['treeSelection'];
-    batchOperationDelay: DataSourceProps<T>['batchOperationDelay'];
-    onDataArrayChange: DataSourceProps<T>['onDataArrayChange'];
-    onDataMutations: DataSourceProps<T>['onDataMutations'];
-    onTreeDataMutations: TreeDataSourceProps<T>['onTreeDataMutations'];
-    onReady: DataSourceProps<T>['onReady'];
-    rowInfoReducers: DataSourceProps<T>['rowInfoReducers'];
-    lazyLoad: DataSourceProps<T>['lazyLoad'];
-    useGroupKeysForMultiRowSelection: NonUndefined<DataSourceProps<T>['useGroupKeysForMultiRowSelection']>;
-    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
-    data: DataSourceProps<T>['data'];
-    sortFunction: DataSourceProps<T>['sortFunction'];
-    filterFunction: DataSourceProps<T>['filterFunction'];
-    treeFilterFunction: DataSourceProps<T>['treeFilterFunction'];
-    filterValue: DataSourceProps<T>['filterValue'];
-    filterTypes: NonUndefined<DataSourceProps<T>['filterTypes']>;
-    primaryKey: DataSourceProps<T>['primaryKey'];
-    filterDelay: NonUndefined<DataSourceProps<T>['filterDelay']>;
-    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
-    pivotBy: DataSourceProps<T>['pivotBy'];
-    loading: NonUndefined<DataSourceProps<T>['loading']>;
-    sortTypes: NonUndefined<DataSourceProps<T>['sortTypes']>;
-    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
-    sortInfo: DataSourceSingleSortInfo<T>[] | null;
-    rowDisabledState: RowDisabledState<T> | null;
-}
-type DataSourceRawReducer<T, RESULT_TYPE> = {
-    initialValue?: RESULT_TYPE | (() => RESULT_TYPE);
-    reducer: (accumulator: any, value: T) => RESULT_TYPE;
-    done?: (accumulatedValue: RESULT_TYPE, array: T[]) => RESULT_TYPE;
-};
-type DataSourceAggregationReducer<T, AggregationResultType> = {
-    name?: string;
-    field?: keyof T;
-    initialValue?: AggregationResultType | (() => any);
-    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>>>);
-};
-type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
-    inheritFromColumn?: string | boolean;
-};
-type DataSourceMappings = Record<'totals' | 'values', string>;
-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>;
-    };
-};
-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;
-};
-type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
-type DebugTimingKey = 'group-and-pivot' | 'filter' | 'sort' | 'pivot' | 'tree';
-interface DataSourceSetupState<T> {
-    logger: DebugLogger;
-    forceRerenderTimestamp: number;
-    devToolsDetected: boolean;
-    debugTimings: Map<DebugTimingKey, number>;
-    debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
-    indexer: Indexer<T, any>;
-    getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
-    __apiRef: React$1.MutableRefObject<DataSourceApi<T> | null>;
-    lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<{
-        nodePath: NodePath$1;
-        selected: boolean;
-    } | null>;
-    lastExpandStateInfoRef: React$1.MutableRefObject<{
-        state: 'collapsed' | 'expanded';
-        nodePath: NodePath$1 | null;
-    }>;
-    waitForNodePathPromises: DeepMap<any, {
-        timestamp: number;
-        promise: Promise<boolean>;
-        resolve: (value: boolean) => void;
-    }>;
-    repeatWrappedGroupRows: InfiniteTablePropRepeatWrappedGroupRows<T>;
-    /**
-     * This is just used for horizontal layout and when repeatWrappedGroupRows is TRUE!!!
-     */
-    rowsPerPage: number | null;
-    totalLeafNodesCount: number;
-    destroyedRef: React$1.MutableRefObject<boolean>;
-    idToIndexMap: Map<any, number>;
-    idToPathMap: Map<any, NodePath$1>;
-    pathToIndexMap: DeepMap<any, number>;
-    detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
-    treeSelectionState?: TreeSelectionState;
-    stateReadyAsDetails: boolean;
-    cache?: DataSourceCache<T>;
-    unfilteredCount: number;
-    filteredCount: number;
-    rowInfoReducerResults?: Record<string, any>;
-    originalDataArrayChanged: boolean;
-    originalDataArrayChangedInfo: {
-        timestamp: number;
-        mutations?: Map<string, DataSourceMutation<T>[]>;
-        treeMutations?: DeepMap<any, DataSourceMutation<T>[]>;
-    };
-    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;
-    onCleanup: SubscriptionCallback<DataSourceState<T>>;
-    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
-    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
-    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
-    originalDataArray: T[];
-    lastFilterDataArray?: T[];
-    lastSortDataArray?: T[];
-    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
-    lastTreeDataArray?: InfiniteTableRowInfo<T>[];
-    dataArray: InfiniteTableRowInfo<T>[];
-    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
-    treeDeepMap?: DeepMap<TreeKeyType, DeepMapTreeValueType<T, any>>;
-    treePaths?: DeepMap<TreeKeyType, true>;
-    unfilteredTreePaths?: DeepMap<TreeKeyType, true>;
-    groupRowsIndexesInDataArray?: number[];
-    reducerResults?: Record<string, AggregationReducerResult>;
-    allRowsSelected: boolean;
-    someRowsSelected: boolean;
-    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
-    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
-    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
-    updatedAt: number;
-    reducedAt: number;
-    groupedAt: number;
-    treeAt: number;
-    sortedAt: number;
-    filteredAt: number;
-    generateGroupRows: boolean;
-    postFilterDataArray?: T[];
-    postSortDataArray?: T[];
-    postGroupDataArray?: InfiniteTableRowInfo<T>[];
-    pivotColumns?: Record<string, InfiniteTableColumn<T>>;
-    pivotColumnGroups?: Record<string, InfiniteTableColumnGroup>;
-}
-type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
-type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
-type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
-type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
-type TreeSelectionValue = TreeSelectionStateObject | TreeSelectionState;
-
-type DataSourcePropTreeSelection_MultiNode = TreeSelectionValue;
-type DataSourcePropRowSelection_SingleRow = null | string | number;
-type DataSourcePropTreeSelection_SingleNode = null | string | number;
-type DataSourcePropTreeSelection = DataSourcePropTreeSelection_MultiNode | DataSourcePropTreeSelection_SingleNode;
-type DataSourcePropCellSelection_MultiCell = CellSelectionStateObject | CellSelectionState;
-type DataSourcePropCellSelection_SingleCell = null | CellSelectionPosition;
-type DataSourcePropCellSelection = DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
-type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
-type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
-type DataSourcePropOnTreeSelectionChange_MultiNode<T = any> = (treeSelectionStateObject: TreeSelectionStateObject, params: {
-    treeSelectionState: TreeSelectionState<T>;
-    prevTreeSelectionState: TreeSelectionState<T>;
-    unfilteredTreePaths: DeepMap<TreeKeyType, true>;
-    selectionMode: 'multi-row';
-    lastUpdatedNodeInfo: {
-        nodePath: NodePath$1;
-        selected: boolean;
-    } | null;
-    dataSourceApi: DataSourceApi<T>;
-    treeApi: TreeApi<T>;
-}) => void;
-type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
-type DataSourcePropOnTreeSelectionChange_SingleNode = (treeSelection: DataSourcePropTreeSelection_SingleNode, params: {
-    selectionMode: 'single-row';
-}) => void;
-type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
-type DataSourcePropOnTreeSelectionChange = DataSourcePropOnTreeSelectionChange_SingleNode | DataSourcePropOnTreeSelectionChange_MultiNode;
-type DataSourcePropOnCellSelectionChange_MultiCell = (cellSelection: DataSourcePropCellSelection_MultiCell, selectionMode: 'multi-cell') => void;
-type DataSourcePropOnCellSelectionChange_SingleCell = (cellSelection: DataSourcePropCellSelection_SingleCell, selectionMode: 'single-cell') => void;
-type DataSourcePropOnCellSelectionChange = DataSourcePropOnCellSelectionChange_MultiCell | DataSourcePropOnCellSelectionChange_SingleCell;
-type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
-type DataSourcePropIsNodeReadOnly<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>) => boolean;
-type DataSourcePropIsNodeSelected<T> = (rowInfo: InfiniteTable_Tree_RowInfoNode<T>, treeSelectionState: TreeSelectionState, selectionMode: 'multi-row') => boolean | null;
-type DataSourcePropIsNodeSelectable<T> = (rowInfo: InfiniteTable_Tree_RowInfoNode<T>) => boolean;
-type DataSourcePropIsNodeExpanded<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>, treeExpandState: TreeExpandState) => boolean;
-type DataSourcePropSortFn<T> = (sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: (item: any) => T) => T[];
-type DataSourceCRUDParam = {
-    flush?: boolean;
-    metadata?: any;
+type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
+    rowIndexInHorizontalLayoutPage: null | number;
+    horizontalLayoutPageIndex: null | number;
+    value: string | number | Renderable;
+    align: InfiniteTableColumnAlignValues;
+    verticalAlign: InfiniteTableColumnVerticalAlignValues;
+    renderBag: InfiniteTableColumnRenderBag;
+    rowIndex: number;
+    rowActive: boolean;
+    api: InfiniteTableApi<DATA_TYPE>;
+    dataSourceApi: DataSourceApi<DATA_TYPE>;
+    editError?: Error;
+    column: COL_TYPE;
+    columnsMap: Map<string, COL_TYPE>;
+    fieldsToColumn: Map<keyof DATA_TYPE, COL_TYPE>;
+    groupByColumn?: InfiniteTableComputedColumn<DATA_TYPE>;
+    toggleCurrentGroupRow: () => void;
+    toggleCurrentTreeNode: () => void;
+    expandTreeNode: InfiniteTableToggleTreeNodeFn;
+    collapseTreeNode: InfiniteTableToggleTreeNodeFn;
+    toggleGroupRow: InfiniteTableToggleGroupRowFn;
+    toggleTreeNode: InfiniteTableToggleTreeNodeFn;
+    toggleCurrentTreeNodeSelection: () => void;
+    toggleCurrentGroupRowSelection: () => void;
+    toggleCurrentRowSelection: () => void;
+    toggleCurrentRowDetails: () => void;
+    toggleRowDetails: InfiniteTableToggleRowDetailsFn;
+    expandRowDetails: InfiniteTableToggleRowDetailsFn;
+    collapseRowDetails: InfiniteTableToggleRowDetailsFn;
+    rowHasSelectedCells: boolean;
+    cellSelected: boolean;
+    selectCurrentRow: () => void;
+    selectRow: InfiniteTableSelectRowFn;
+    deselectRow: InfiniteTableSelectRowFn;
+    deselectCurrentRow: () => void;
+    selectCell: () => void;
+    deselectCell: () => void;
+    toggleRowSelection: InfiniteTableSelectRowFn;
+    toggleGroupRowSelection: InfiniteTableToggleGroupRowFn;
+    toggleTreeNodeSelection: InfiniteTableToggleTreeNodeFn;
+    selectTreeNode: InfiniteTableToggleTreeNodeFn;
+    deselectTreeNode: InfiniteTableToggleTreeNodeFn;
+    selectionMode: DataSourcePropSelectionMode | undefined;
+    rootGroupBy: DataSourceState<DATA_TYPE>['groupBy'];
+    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
 };
-type WaitForNodeOptions = {
-    waitForNode?: boolean | number;
+type InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
+type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE>;
+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;
 };
-type DataSourceUpdateParam = DataSourceCRUDParam & WaitForNodeOptions;
-type DataSourceInsertParam = DataSourceCRUDParam & WaitForNodeOptions & ({
-    position: 'before' | 'after';
-    primaryKey: any;
-    nodePath?: never;
-} | {
-    position: 'before' | 'after';
-    primaryKey?: never;
-    nodePath: NodePath$1;
-} | {
-    position: 'start' | 'end';
-    nodePath?: never;
-} | {
-    position: 'start' | 'end';
-    nodePath: NodePath$1;
-});
-type UpdateChildrenFn<T> = (dataChildren: T[] | undefined | null, data: T) => T[] | undefined | null;
-interface DataSourceApi<T> {
-    getPendingOperationPromise(): Promise<boolean> | null;
-    getOriginalDataArray: () => T[];
-    getRowInfoArray: () => InfiniteTableRowInfo<T>[];
-    getDataByPrimaryKey(id: any): T | null;
-    getDataByNodePath(nodePath: NodePath$1): T | null;
-    getDataByIndex(index: number): T | null;
-    getRowInfoByIndex(index: number): InfiniteTableRowInfo<T> | null;
-    getRowInfoByPrimaryKey(id: any): InfiniteTableRowInfo<T> | null;
-    getRowInfoByNodePath(nodePath: NodePath$1): InfiniteTableRowInfo<T> | null;
-    getIndexByPrimaryKey(id: any): number;
-    getIndexByNodePath(nodePath: NodePath$1): number;
-    getPrimaryKeyByIndex(id: any): any;
-    getNodePathById(id: any): NodePath$1 | null;
-    getNodePathByIndex(index: number): NodePath$1 | null;
-    get treeApi(): TreeApi<T>;
-    /**
-     * @param nodePath The node path to wait for
-     * @param options
-     * @param options.timeout The timeout to wait for the node path to be available. Defaults to 1000ms.
-     *
-     * @returns true if the path is already in the DataSource, otherwise a promise resolving to a boolean value.
-     * If the timeout is reached and the path is not available, the promise is resolved to false. Otherwise, the promise is resolved to true.
-     */
-    waitForNodePath(nodePath: NodePath$1, options?: {
-        timeout?: number;
-    }): Promise<boolean>;
-    isNodePathAvailable(nodePath: NodePath$1): boolean;
-    updateData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
-    updateDataByNodePath(data: Partial<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
-    updateChildrenByNodePath(childrenOrFn: T[] | undefined | null | UpdateChildrenFn<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
-    updateDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
-    updateDataArrayByNodePath(updateInfo: {
-        data: Partial<T>;
-        nodePath: NodePath$1;
-    }[], options?: DataSourceUpdateParam): Promise<any>;
-    flush(): Promise<any>;
-    removeDataByPrimaryKey(id: any, options?: DataSourceCRUDParam): Promise<any>;
-    removeDataByNodePath(nodePath: NodePath$1, options?: DataSourceCRUDParam): Promise<any>;
-    removeDataArrayByPrimaryKeys(id: any[], options?: DataSourceCRUDParam): Promise<any>;
-    removeData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
-    removeDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
-    clearAllData(options?: DataSourceCRUDParam): Promise<any>;
-    replaceAllData(data: T[], options?: DataSourceCRUDParam): Promise<any>;
-    addData(data: T, options?: DataSourceCRUDParam): Promise<any>;
-    addDataArray(data: T[], options?: DataSourceCRUDParam): Promise<any>;
-    insertData(data: T, options: DataSourceInsertParam): Promise<any>;
-    insertDataArray(data: T[], options: DataSourceInsertParam): Promise<any>;
-    setSortInfo(sortInfo: null | DataSourceSingleSortInfo<T>[]): void;
-    isRowDisabledAt: (rowIndex: number) => boolean;
-    isRowDisabled: (primaryKey: any) => boolean;
-    setRowEnabledAt: (rowIndex: number, enabled: boolean) => void;
-    setRowEnabled: (primaryKey: any, enabled: boolean) => void;
-    enableAllRows: () => void;
-    disableAllRows: () => void;
-    areAllRowsEnabled: () => boolean;
-    areAllRowsDisabled: () => boolean;
-    setGroupBy: (groupBy: DataSourceState<T>['groupBy']) => void;
-    toggleGroupByField: (field: keyof T) => void;
-}
-type DataSourcePropRowInfoReducers<T> = Record<string, DataSourceRowInfoReducer<T>>;
-type DataSourceRowInfoReducer<T> = DataSourceRawReducer<InfiniteTableRowInfo<T>, any>;
-type DataSourcePropShouldReloadDataObject<T> = {
-    [key in keyof Pick<DataSourceDataParams<T>, 'sortInfo' | 'pivotBy' | 'groupBy' | 'filterValue'>]: boolean;
+type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
+    isGroupRow: true;
+}) => Renderable | null;
+type InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
+    isTreeNode: true;
+    isParentNode: true;
+}) => Renderable | null;
+type InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
+    isTreeNode: true;
+    isParentNode: false;
+}) => Renderable | null;
+type InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, EXTRA_NODE_PARAMS = Partial<InfiniteTableRowInfoDataDiscriminator_ParentNode<DATA_TYPE> | InfiniteTableRowInfoDataDiscriminator_LeafNode<DATA_TYPE>>, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & EXTRA_NODE_PARAMS) => Renderable | null;
+type InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
+    isGroupRow: false;
+}) => Renderable | null;
+type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE>) => Renderable | null;
+type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
+type InfiniteTableColumnOrHeaderRenderFunction<T> = (params: (InfiniteTableColumnCellContextType<T> & {
+    rowInfo: InfiniteTableRowInfo<T>;
+}) | (InfiniteTableColumnHeaderParam<T> & {
+    rowInfo: null;
+})) => ReturnType<InfiniteTableColumnRenderFunction<T>>;
+type InfiniteTableColumnContentFocusable<T> = boolean | InfiniteTableColumnContentFocusableFn<T>;
+type InfiniteTableColumnEditable<T> = boolean | InfiniteTableColumnEditableFn<T>;
+type InfiniteTableColumnContentFocusableFn<T> = (params: InfiniteTableColumnContentFocusableParams<T>) => boolean;
+type InfiniteTableColumnEditableFn<T> = (params: InfiniteTableColumnEditableParams<T>) => boolean | Promise<boolean>;
+type InfiniteTableColumnContentFocusableParams<T> = InfiniteTableRowInfoDataDiscriminatorWithColumnAndApis<T>;
+type InfiniteTableColumnEditableParams<T> = InfiniteTableColumnContentFocusableParams<T>;
+type InfiniteTableColumnGetValueToPersistParams<T> = InfiniteTableColumnEditableParams<T> & {
+    initialValue: any;
 };
-type DataSourcePropShouldReloadData<T> = DataSourcePropShouldReloadDataObject<T> | boolean;
-type TreeExpandStateValue = TreeExpandState | TreeExpandStateObject<any>;
-type DataSourceProps<T> = {
-    nodesKey?: never;
-    debugId?: string;
-    children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
-    primaryKey: keyof T | ((data: T) => string);
-    /**
-     * @deprecated for now
-     */
-    fields?: (keyof T)[];
-    refetchKey?: number | string | object;
-    batchOperationDelay?: number;
-    rowInfoReducers?: DataSourcePropRowInfoReducers<T>;
-    data: DataSourceData<T>;
-    selectionMode?: DataSourcePropSelectionMode;
-    useGroupKeysForMultiRowSelection?: boolean;
-    rowSelection?: DataSourcePropRowSelection;
-    defaultRowSelection?: DataSourcePropRowSelection;
-    cellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
-    defaultCellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
-    onCellSelectionChange?: DataSourcePropOnCellSelectionChange;
-    rowDisabledState?: RowDisabledState | RowDisabledStateObject<any>;
-    defaultRowDisabledState?: RowDisabledState | RowDisabledStateObject<any>;
-    onRowDisabledStateChange?: (rowDisabledState: RowDisabledState) => void;
-    isRowDisabled?: (rowInfo: InfiniteTableRowInfo<T>) => boolean;
-    isRowSelected?: DataSourcePropIsRowSelected<T>;
-    lazyLoad?: boolean | {
-        batchSize?: number;
-    };
-    loading?: boolean;
-    defaultLoading?: boolean;
-    onLoadingChange?: (loading: boolean) => void;
-    onReady?: (api: DataSourceApi<T>) => 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?: DataSourcePropGroupRowsState<any>;
-    defaultGroupRowsState?: DataSourcePropGroupRowsState<any>;
-    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
-    collapseGroupRowsOnDataFunctionChange?: boolean;
-    sortFunction?: DataSourcePropSortFn<T>;
-    sortInfo?: DataSourceSortInfo<T>;
-    defaultSortInfo?: DataSourceSortInfo<T>;
-    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
-    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
-    onDataArrayChange?: (dataArray: DataSourceState<T>['originalDataArray'], info: DataSourceState<T>['originalDataArrayChangedInfo']) => void;
-    onDataMutations?: ({ dataArray, timestamp, mutations, primaryKeyField, }: {
-        primaryKeyField: undefined | keyof T;
-        dataArray: DataSourceState<T>['originalDataArray'];
-        timestamp: number;
-        mutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['mutations']>;
-    }) => void;
-    livePagination?: boolean;
-    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
-    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
-    filterFunction?: DataSourcePropFilterFunction<T>;
-    treeFilterFunction?: DataSourcePropTreeFilterFunction<T>;
-    /**
-     * @deprecated Use shouldReloadData.sortInfo instead
-     */
-    sortMode?: 'local' | 'remote';
-    /**
-     * @deprecated Use shouldReloadData.filterValue instead
-     */
-    filterMode?: 'local' | 'remote';
-    /**
-     * @deprecated Use shouldReloadData.groupBy instead
-     */
-    groupMode?: 'local' | 'remote';
-    shouldReloadData?: DataSourcePropShouldReloadData<T>;
-    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';
-    cellSelection?: DataSourcePropCellSelection_SingleCell;
-    defaultCellSelection?: DataSourcePropCellSelection_SingleCell;
-    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_SingleCell;
-} | {
-    selectionMode?: 'multi-cell';
-    cellSelection?: DataSourcePropCellSelection_MultiCell;
-    defaultCellSelection?: DataSourcePropCellSelection_MultiCell;
-    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_MultiCell;
-} | {
-    selectionMode?: false;
-});
+type InfiniteTableColumnAlignValues = 'start' | 'center' | 'end';
+type InfiniteTableColumnVerticalAlignValues = 'start' | 'center' | 'end';
+type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
+type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
+type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
+type InfiniteTableColumnStylingFnParams<T> = {
+    value: Renderable;
+    column: InfiniteTableComputedColumn<T>;
+    rowIndexInHorizontalLayoutPage: null | number;
+    horizontalLayoutPageIndex: null | number;
+    inEdit: boolean;
+    rowHasSelectedCells: boolean;
+    editError: InfiniteTableColumnRenderParamBase<T>['editError'];
+} & InfiniteTableRowInfoDataDiscriminator<T>;
+type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStylingFnParams<T>) => undefined | React$1.CSSProperties;
+type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
+type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React$1.CSSProperties;
+type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStylingFnParams<T>) => undefined | string;
+type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
+type InfiniteTableColumnAlign<T> = InfiniteTableColumnAlignValues | InfiniteTableColumnAlignFn<T>;
+type InfiniteTableColumnVerticalAlign<T> = InfiniteTableColumnVerticalAlignValues | InfiniteTableColumnVerticalAlignFn<T>;
+type InfiniteTableColumnAlignFn<T> = (params: InfiniteTableColumnAlignFnParams<T>) => InfiniteTableColumnAlignValues;
+type InfiniteTableColumnAlignFnParams<T> = XOR<{
+    isHeader: true;
+    column: InfiniteTableComputedColumn<T>;
+}, InfiniteTableColumnStylingFnParams<T> & {
+    isHeader: false;
+}>;
+type InfiniteTableColumnVerticalAlignFn<T> = (params: InfiniteTableColumnAlignFnParams<T>) => InfiniteTableColumnVerticalAlignValues;
+type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
+type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
+type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
+type InfiniteTableColumnValueGetterParams<T> = ValueGetterParams<T>;
+type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
+type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
+type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
+type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
+type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
+type InfiniteTableColumnSortableFn<T> = (context: {
+    api: InfiniteTableApi<T>;
+    columnApi: InfiniteTableColumnApi<T>;
+    column: InfiniteTableComputedColumn<T>;
+    columns: Map<string, InfiniteTableComputedColumn<T>>;
+}) => boolean;
+type InfiniteTableColumnSortable<T> = boolean | InfiniteTableColumnSortableFn<T>;
 /**
- * @deprecated Use DataSourceProps<T> instead
+ * 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`.
  */
-type DataSourcePropsWithChildren<T> = DataSourceProps<T> & {};
-type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
-type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
-type DataSourceFilterFunctionParam<T> = {
-    data: T;
-    index: number;
-    dataArray: T[];
-    primaryKey: any;
-};
-type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
-type DataSourcePropTreeFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T> & {
-    filterTreeNode: (data: T) => T | boolean;
-}) => T | boolean;
-type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
-type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
-    field: keyof T;
-}, {
-    id: string;
-}> & {
-    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
-    filter: {
-        type: string;
-        operator: string;
-        value: any;
-    };
-    disabled?: boolean;
-};
-type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T> & {
-    field?: keyof T;
-}) => any;
-type DataSourceFilterType<T> = {
-    emptyValues: any[];
-    label?: string;
-    defaultOperator: string;
-    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
-    components?: {
-        FilterEditor?: () => React$1.JSX.Element | null;
-        FilterOperatorSwitch?: () => React$1.JSX.Element | null;
+type InfiniteTableColumn<DATA_TYPE> = {
+    field?: KeyOfNoSymbol<DATA_TYPE>;
+    valueGetter?: InfiniteTableColumnValueGetter<DATA_TYPE>;
+    defaultSortable?: InfiniteTableColumnSortable<DATA_TYPE>;
+    /**
+     * Whether the column is draggable by default.
+     *
+     * This prop overrides the top-level columnDefaultDraggable prop, but is
+     * overridden by the top-level draggableColumns prop.
+     */
+    defaultDraggable?: boolean;
+    resizable?: boolean;
+    shouldAcceptEdit?: (params: InfiniteTablePropOnEditAcceptedParams<DATA_TYPE>) => boolean | Error | Promise<boolean | Error>;
+    contentFocusable?: InfiniteTableColumnContentFocusable<DATA_TYPE>;
+    defaultEditable?: InfiniteTableColumnEditable<DATA_TYPE>;
+    getValueToEdit?: (params: InfiniteTableColumnEditableParams<DATA_TYPE>) => any | Promise<any>;
+    getValueToPersist?: (params: InfiniteTableColumnGetValueToPersistParams<DATA_TYPE>) => any | Promise<any>;
+    comparer?: InfiniteTableColumnComparer<DATA_TYPE>;
+    defaultHiddenWhenGroupedBy?: '*' | true | keyof DATA_TYPE | {
+        [k in keyof Partial<DATA_TYPE>]: true;
     };
-    operators: DataSourceFilterOperator<T>[];
-};
-type DataSourceFilterOperator<T> = {
-    name: string;
-    label?: string;
+    align?: InfiniteTableColumnAlign<DATA_TYPE>;
+    headerAlign?: InfiniteTableColumnAlign<DATA_TYPE>;
+    verticalAlign?: InfiniteTableColumnVerticalAlign<DATA_TYPE>;
+    columnGroup?: string;
+    header?: InfiniteTableColumnHeader<DATA_TYPE>;
+    renderHeader?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
+    name?: Renderable;
+    cssEllipsis?: boolean;
+    headerCssEllipsis?: boolean;
+    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
+    dataType?: InfiniteTableDataTypeNames;
+    sortType?: string | string[];
+    filterType?: string;
+    style?: InfiniteTableColumnStyle<DATA_TYPE>;
+    headerStyle?: InfiniteTableColumnHeaderStyle<DATA_TYPE>;
+    headerClassName?: InfiniteTableColumnHeaderClassName<DATA_TYPE>;
+    className?: InfiniteTableColumnClassName<DATA_TYPE>;
+    rowspan?: InfiniteTableColumnRowspanFn<DATA_TYPE>;
+    render?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderValue?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderGroupValue?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
+    renderLeafValue?: InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE>;
+    valueFormatter?: InfiniteTableColumnValueFormatter<DATA_TYPE, Renderable>;
+    defaultWidth?: number;
+    defaultFlex?: number;
+    defaultFilterable?: boolean;
+    defaultGroupable?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
+    renderRowDetailIcon?: boolean | InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderTreeIcon?: boolean | InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, {
+        isTreeNode: true;
+        isParentNode: boolean;
+        isGroupRow: false;
+        nodeExpanded: boolean;
+    }>;
+    renderTreeIconForParentNode?: InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, {
+        isTreeNode: true;
+        isGroupRow: true;
+        isParentNode: true;
+    }>;
+    renderTreeIconForLeafNode?: InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, {
+        isTreeNode: true;
+        isGroupRow: false;
+        isLeafNode: true;
+    }>;
+    renderSortIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
+    renderFilterIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
+    renderSelectionCheckBox?: boolean | InfiniteTableColumnOrHeaderRenderFunction<DATA_TYPE>;
+    renderMenuIcon?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
+    renderHeaderSelectionCheckBox?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
     components?: {
-        FilterEditor?: () => React$1.JSX.Element | null;
-        Icon?: (props: any) => React$1.JSX.Element | null;
+        ColumnCell?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
+        HeaderCell?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
+        Editor?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
+        FilterEditor?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
+        FilterOperatorSwitch?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
+        MenuIcon?: React$1.ComponentType<MenuIconProps>;
     };
-    fn: DataSourceFilterOperatorFunction<T>;
-    defaultFilterValue?: any;
-};
-type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
-type DataSourceFilterOperatorFunctionParam<T> = {
-    currentValue: any;
-    filterValue: any;
-    emptyValues: any[];
-    field?: keyof T;
-} & DataSourceFilterFunctionParam<T>;
-type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
-type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
-type DataSourceLivePaginationCursorParams<T> = {
-    array: T[];
-    lastItem: T | Partial<T> | null;
-    length: number;
-};
-type DataSourceLivePaginationCursorValue = string | number | null;
-interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
-}
-type DataSourceCallback_BaseParam<T> = {
-    dataSourceApi: DataSourceApi<T>;
-};
-type DataSourceDerivedState<T> = {
-    debugId: DataSourceProps<T>['debugId'];
-    isTree: boolean;
-    toPrimaryKey: (data: T) => any;
-    operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
-    sortMode: 'local' | 'remote';
-    filterMode: 'local' | 'remote';
-    groupMode: 'local' | 'remote';
-    pivotMode: 'local' | 'remote';
-    shouldReloadData: NonUndefined<Required<DataSourcePropShouldReloadDataObject<T>>>;
-    groupRowsState: GroupRowsState<T>;
-    treeExpandState: TreeExpandState<any>;
-    treeExpandMode: TreeExpandStateMode;
-    multiSort: boolean;
-    controlledSort: boolean;
-    controlledFilter: boolean;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-    lazyLoadBatchSize?: number;
-    rowSelection: RowSelectionState | null | number | string;
-    isRowDisabled: DataSourceProps<T>['isRowDisabled'];
-    cellSelection: CellSelectionState | null;
-    selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
-};
-type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
-interface DataSourceContextValue<T> {
-    api: DataSourceApi<T>;
-    getState: () => DataSourceState<T>;
-    assignState: (state: Partial<DataSourceState<T>>) => void;
-    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue<any> | undefined;
-    componentState: DataSourceState<T>;
-    componentActions: DataSourceComponentActions<T>;
-}
-interface DataSourceMasterDetailContextValue<MASTER_TYPE = any> {
-    registerDetail: (detail: DataSourceContextValue<any>) => void;
-    getMasterState: () => InfiniteTableState<MASTER_TYPE>;
-    getMasterDataSourceState: () => DataSourceState<MASTER_TYPE>;
-    shouldRestoreState: boolean;
-    masterRowInfo: InfiniteTableRowInfo<MASTER_TYPE>;
-}
-declare enum DataSourceActionType {
-    INIT = "INIT"
-}
-interface DataSourceAction<T> {
-    type: DataSourceActionType;
-    payload: T;
-}
-
-declare class RowDetailState<KeyType = any> extends BooleanCollectionState<RowDetailStateObject<KeyType>, KeyType> {
-    constructor(state: RowDetailStateObject<KeyType> | RowDetailState<KeyType>);
-    getState(): RowDetailStateObject<KeyType>;
-    getPositiveFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
-    getNegativeFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
-    areAllCollapsed(): boolean;
-    areAllExpanded(): boolean;
-    collapseAll(): void;
-    expandAll(): void;
-    isRowDetailsExpanded: (key: KeyType) => boolean;
-    isRowDetailsCollapsed(key: KeyType): boolean;
-    setRowDetailsExpanded(key: KeyType, shouldExpand: boolean): void;
-    collapseRowDetails(key: KeyType): void;
-    expandRowDetails(key: KeyType): void;
-    toggleRowDetails(key: KeyType): void;
-}
-
-type TableRenderCellFnParam = {
-    domRef: RefCallback<HTMLElement>;
-    rowIndex: number;
-    colIndex: number;
-    rowspan: number;
-    colspan: number;
-    hidden: boolean;
-    width: number;
-    height: number;
-    widthWithColspan: number;
-    heightWithRowspan: number;
-    rowFixed: FixedPosition;
-    colFixed: FixedPosition;
-    onMouseEnter: VoidFunction;
-    onMouseLeave: VoidFunction;
 };
-type TableRenderDetailRowFnParam = {
-    domRef: RefCallback<HTMLElement>;
-    rowIndex: number;
-    hidden: boolean;
-    height: number;
-    rowFixed: FixedPosition;
-    onMouseEnter: VoidFunction;
-    onMouseLeave: VoidFunction;
+type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'defaultSortable'> & {
+    groupByForColumn: GroupBy<T> | GroupBy<T>[];
+    id?: string;
 };
-type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
-type TableRenderDetailRowFn = (param: TableRenderDetailRowFnParam) => Renderable;
-type RenderRangeOptions = {
-    force?: boolean;
-    renderCell: TableRenderCellFn;
-    renderDetailRow?: TableRenderDetailRowFn;
-    onRender: (items: Renderable[]) => void;
+type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
+type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotTotalColumnGroup?: true;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex: PivotBy<DataType, KeyType>;
+    pivotGroupKey: KeyType;
+    pivotIndex: number;
 };
-type HorizontalLayoutColVisibilityOptions = {
-    horizontalLayoutPageIndex?: number;
+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;
 };
+type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
+type InfiniteTableComputedColumnBase<T> = {
+    computedFilterType: string;
+    computedSortType: string | string[];
+    computedDataType: string;
+    computedWidth: number;
+    computedFlex: number | null;
+    computedMinWidth: number;
+    computedMaxWidth: number;
+    computedOffset: number;
+    computedPinningOffset: number;
+    computedAbsoluteOffset: number;
+    computedSortInfo: DataSourceSingleSortInfo<T> | null;
+    computedSorted: boolean;
+    computedSortedAsc: boolean;
+    computedSortedDesc: boolean;
+    computedSortIndex: number;
+    computedVisible: boolean;
+    computedVisibleIndex: number;
+    computedVisibleIndexInCategory: number;
+    computedMultiSort: boolean;
+    computedFiltered: boolean;
+    computedFilterable: boolean;
+    computedGroupedBy: boolean;
+    computedGroupedByIndex: number | undefined;
+    computedGroupable: boolean;
+    computedFilterValue: DataSourceFilterValueItem<T> | null;
+    computedPinned: InfiniteTableColumnPinnedValues;
+    computedDraggable: boolean;
+    computedResizable: boolean;
+    computedFirstInCategory: boolean;
+    computedLastInCategory: boolean;
+    computedFirst: boolean;
+    computedLast: boolean;
+    computedEditable: NonUndefined<InfiniteTableColumn<T>['defaultEditable']>;
+    computedSortable: NonUndefined<InfiniteTableColumn<T>['defaultSortable']>;
+    colType: InfiniteTableColumnType<T>;
+    id: string;
+};
+type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
+type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 
-interface GridCellInterface<T_ADDITIONAL_CELL_INFO = any> {
-    debugId: string;
-    update(content: Renderable, additionalInfo?: T_ADDITIONAL_CELL_INFO, scrollingObjectParam?: {
-        scrolling: boolean;
-    }): void;
-    getElement(): HTMLElement | null;
-    getNode(): Renderable;
-    destroy(): void;
-    onMount(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
-    getAdditionalInfo(): T_ADDITIONAL_CELL_INFO | undefined;
-    isMounted(): boolean;
-    ref: React.RefCallback<HTMLElement | undefined>;
-}
-
-type CellPos = [number, number];
-
-declare class GridCellManager<T_ADDITIONAL_CELL_INFO> extends Logger {
-    private matrix;
-    private rowsWithCellsHistory;
-    private columnsWithCellsHistory;
-    private cellToMatrixPosition;
-    private pool;
-    debugId: string;
-    private offRemoveCell;
-    constructor(debugId: string);
-    private onRemoveCell;
-    set poolSize(cellCount: number);
-    get poolSize(): number;
-    getDetachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
-    private clearCellFromMatrix;
-    private addCellToMatrix;
-    private setCellPositionInMatrix;
-    renderNodeAtCell(node: Renderable, cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, cellPos: CellPos, additionalInfo?: T_ADDITIONAL_CELL_INFO, scrollingObjectParam?: {
-        scrolling: boolean;
-    }): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
-    getCellPosition(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): CellPos | null;
-    getCellAt(cellPos: CellPos): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    /**
-     * This gets a cell for a given position.
-     * If there's already a cell currently attached at that position, it will be returned.
-     *
-     * Otherwise, we try to return the most optimal cell to use for that position.
-     * If the optimise parameter is set to 'row', we will try to return a detached cell
-     * that was last rendered in that row.
-     *
-     * If the optimise parameter is set to 'column', we will try to return a detached cell
-     * that was last rendered in that column.
-     *
-     * @param cellPos [rowIndex, colIndex]
-     * @param optimise 'row' | 'column'
-     */
-    getCellFor(cellPos: CellPos, optimise: 'row' | 'column'): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
-    isCellAttached(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
-    isCellAttachedAt(cellPos: CellPos): boolean;
-    getMatrix(): Renderable[][];
-    getAllCells(): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
-    getCellsForRow(rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
-    getOneAttachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    getRowsWithCells(): number[];
-    getColumnsWithCells(): number[];
-    isRowAttached(rowIndex: number): boolean;
-    isColumnAttached(colIndex: number): boolean;
-    detachRow(rowIndex: number): void;
-    detachCol(colIndex: number): void;
-    detachCell(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
-    detachCells(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>): void;
-    detachRowsStartingWith(rowIndex: number): void;
-    detachColsStartingWith(colIndex: number): void;
-    detachCellsStartingAt(cellPos: CellPos): void;
-    detachCellAt(cellPos: CellPos): boolean;
-    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFn;
-    getCellsOutsideRenderRange: (range: TableRenderRange) => Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
-    getCellFromListForRow(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    getCellFromListForColumn(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, colIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    getCellCountInMatrix(): number;
-    destroy(): void;
-    reset(): void;
-    makeDetachedCellsEmpty(): void;
-    withDetachedCells(fn: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
-}
-
-/**
- * This is only used for rendering Detail rows in a master-detail DataGrid
- */
-interface ListRowInterface {
-    debugId: string;
-    update(content: Renderable): void;
-    getElement(): HTMLElement | null;
-    getNode(): Renderable;
-    destroy(): void;
-    onMount(callback: (row: ListRowInterface) => void): void;
-    isMounted(): boolean;
-    ref: (htmlElement: HTMLElement) => void;
-}
-
-declare class ListRowManager extends Logger {
-    private pool;
-    private indexToRow;
-    private rowToIndex;
-    debugId: string;
-    private offRemoveRow;
-    constructor(debugId: string);
-    private onRemoveRow;
-    set poolSize(rowCount: number);
-    get poolSize(): number;
-    getDetachedRow(): ListRowInterface;
-    /**
-     * This gets a row for a given position.
-     * If there's already a row currently attached at that position, it will be returned.
-     *
-     * Otherwise, we return another row.
-     * @param rowIndex
-     */
-    getRowFor(rowIndex: number): ListRowInterface;
-    private setRowIndexInList;
-    detachStartingWith(rowIndex: number): void;
-    getRowAt(rowPos: number): ListRowInterface | undefined;
-    getRowIndex(row: ListRowInterface): number | undefined;
-    isRowAttached(row: ListRowInterface): boolean;
-    isRowAttachedAt(rowIndex: number): boolean;
-    getList(): Renderable[];
-    getAttachedCount(): number;
-    forEachAttachedRow(fn: (row: ListRowInterface) => void): void;
-    getAttachedIndexes(): number[];
-    getAllRows(): ListRowInterface[];
-    detachRowAt(rowIndex: number): void;
-    detachRow(row: ListRowInterface): void;
-    renderNodeAtRow(node: Renderable, row: ListRowInterface, rowIndex: number): ListRowInterface;
-    makeDetachedRowsEmpty(): void;
-    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFn;
-    withDetachedRows(fn: (row: ListRowInterface) => void): void;
-    destroy(): void;
-    reset(): void;
-}
+declare const DS_ERROR_CODES: Record<"DS001", DebugWarningPayload>;
+declare const INFINITE_ERROR_CODES: Record<"CSS001_CSS", DebugWarningPayload>;
+declare const ERROR_CODES: {
+    CSS001_CSS: DebugWarningPayload;
+    DS001: DebugWarningPayload;
+};
 
-declare class GridRenderer extends Logger {
-    protected brain: MatrixBrain;
+type DevToolsMessageAddress = 'infinite-table-devtools-contentscript' | 'infinite-table-devtools-contentscript-panel' | 'infinite-table-devtools-background' | 'infinite-table-page';
+type DevToolsGenericMessage = {
+    source: DevToolsMessageAddress;
+    target: DevToolsMessageAddress;
+    payload: any;
+    type: string;
+};
+type ErrorCodeKey = keyof typeof ERROR_CODES;
+type DataSourceDebugWarningKey = keyof typeof DS_ERROR_CODES;
+type InfiniteTableDebugWarningKey = keyof typeof INFINITE_ERROR_CODES;
+type DebugWarningPayload = {
+    message: string;
+    code: ErrorCodeKey;
+    type: 'error' | 'warning';
+    status?: 'new' | 'discarded';
+    debugId?: string;
+};
+type DevToolsHookFnOptions = {
+    getState: () => InfiniteTableState<any>;
+    getDataSourceState: () => DataSourceState<any>;
+    getComputed: () => InfiniteTableComputedValues<any>;
+    actions: InfiniteTableActions<any>;
+    dataSourceActions: DataSourceComponentActions<any>;
+    api: InfiniteTableApi<any>;
+    dataSourceApi: DataSourceApi<any>;
+};
+type DevToolsOverrides = Partial<DevToolsInfiniteOverrides & DevToolsDataSourceOverrides>;
+type DevToolsInfiniteOverrides = Partial<{
+    groupRenderStrategy: InfiniteTableState<any>['groupRenderStrategy'];
+    columnVisibility: InfiniteTableState<any>['columnVisibility'];
+}>;
+type DevToolsDataSourceOverrides = Partial<{
+    groupBy: DataSourceState<any>['groupBy'];
+    sortInfo: DataSourceState<any>['sortInfo'];
+    multiSort: DataSourceState<any>['multiSort'];
+}>;
+type DevToolsHostPageMessagePayload = {
     debugId: string;
-    protected destroyed: boolean;
-    private scrolling;
-    cellHoverClassNames: string[];
-    cellDetachedClassNames: string[];
-    cellManager: GridCellManager<{
-        renderRowIndex: number;
-        renderColIndex: number;
+    columnOrder: string[];
+    visibleColumnIds: string[];
+    columnVisibility: InfiniteTableState<any>['columnVisibility'];
+    columns: Record<string, {
+        field: InfiniteTableComputedColumn<any>['field'];
+        dataType: InfiniteTableComputedColumn<any>['computedDataType'];
+        sortType: InfiniteTableComputedColumn<any>['computedSortType'];
+        filtered: InfiniteTableComputedColumn<any>['computedFiltered'];
+        sorted: InfiniteTableComputedColumn<any>['computedSorted'];
+        width: InfiniteTableComputedColumn<any>['computedWidth'];
     }>;
-    protected rowManager: ListRowManager;
-    private lastEnteredRow;
-    private lastExitedRow;
-    private onDestroy;
-    private hoverRowUpdatesInProgress;
-    private infiniteNode;
-    private getInfiniteNode;
-    setDetailTransform: (element: HTMLElement, _rowIndex: number, { y, scrollTop, scrollLeft, }: {
-        y: number;
-        scrollTop?: boolean;
-        scrollLeft?: number;
-    }) => void;
-    setTransform: (element: HTMLElement, _rowIndex: number, colIndex: number, { x, y, scrollLeft, scrollTop, }: {
-        x: number;
-        y: number;
-        scrollLeft?: boolean;
-        scrollTop?: boolean;
-    }, zIndex: number | "auto" | undefined | null) => void;
-    constructor(brain: MatrixBrain, debugId?: string);
-    private onCellAttached;
-    private onCellDetached;
-    private onRowAttached;
-    private onRowDetached;
-    getFullyVisibleRowsRange: () => {
-        start: number;
-        end: number;
-    } | null;
-    getScrollPositionForScrollRowIntoView: (rowIndex: number, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-        colIndex?: number;
-    }) => ScrollPosition | null;
-    getScrollPositionForScrollColumnIntoView: (colIndex: number, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-    } & HorizontalLayoutColVisibilityOptions) => ScrollPosition | null;
-    getScrollPositionForScrollCellIntoView: (rowIndex: number, colIndex: number, config?: {
-        rowScrollAdjustPosition?: ScrollAdjustPosition;
-        colScrollAdjustPosition?: ScrollAdjustPosition;
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offsetTop: number;
-        offsetLeft: number;
-    }) => ScrollPosition | null;
-    isRowFullyVisible: (rowIndex: number, offsetMargin?: number) => boolean;
-    isRowVisible: (rowIndex: number, offsetMargin?: number) => boolean;
-    isRowRendered: (rowIndex: number) => boolean;
-    isCellVisible: (rowIndex: number, colIndex: number) => boolean;
-    isCellFullyVisible: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isColumnFullyVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isColumnVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isCellRendered: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isColumnRendered: (colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    getExtraSpanCellsForRange: (range: TableRenderRange) => [number, number][];
-    isCellRenderedAndMappedCorrectly(row: number, col: number): {
-        rendered: boolean;
-        mapped: boolean;
-    };
-    renderRange(range: TableRenderRange, { renderCell, renderDetailRow, force, onRender }: RenderRangeOptions): Renderable[];
-    getFixedRanges: (currentRenderRange: TableRenderRange) => TableRenderRange[];
-    protected isCellFixed: (rowIndex: number, colIndex: number) => {
-        row: FixedPosition;
-        col: FixedPosition;
+    groupRenderStrategy: InfiniteTableState<any>['groupRenderStrategy'];
+    groupBy: string[];
+    sortInfo: {
+        field: string;
+        dir: 1 | -1;
+        type?: string;
+    }[];
+    multiSort: DataSourceState<any>['multiSort'];
+    selectionMode: DataSourceState<any>['selectionMode'];
+    devToolsDetected: InfiniteTableState<any>['devToolsDetected'];
+    debugTimings: Record<DebugTimingKey, number>;
+    debugWarnings: Record<ErrorCodeKey, DebugWarningPayload>;
+};
+type DevToolsHostPageMessageType = 'update' | 'unmount' | 'log';
+type DevToolsHostPageLogMessage = {
+    type: Extract<DevToolsHostPageMessageType, 'log'>;
+    payload: DevToolsHostPageLogMessagePayload;
+};
+type DevToolsHostPageLogMessagePayload = {
+    channel: string;
+    color: string;
+    args: any[];
+    timestamp: number;
+    debugId?: string;
+};
+type DevToolsHostPageMessage = {
+    source: Extract<DevToolsMessageAddress, 'infinite-table-page'>;
+    target: Extract<DevToolsMessageAddress, 'infinite-table-devtools-background'>;
+    url: string;
+} & ({
+    type: Extract<DevToolsHostPageMessageType, 'update'>;
+    payload: DevToolsHostPageMessagePayload;
+} | {
+    type: Extract<DevToolsHostPageMessageType, 'unmount'>;
+    payload: {
+        debugId: string;
     };
-    protected isCellCovered: (rowIndex: number, colIndex: number) => false | number[];
-    private renderDetailRowAtElement;
-    protected getCellRealCoordinates(rowIndex: number, colIndex: number): {
+} | DevToolsHostPageLogMessage);
+type DevToolsHookFn = (debugId: string, options: null | DevToolsHookFnOptions) => void;
+
+type CellContextMenuLocation = {
+    rowId: any;
+    rowIndex: number;
+    columnId: string;
+    colIndex: number;
+};
+type CellContextMenuLocationWithEvent = CellContextMenuLocation & {
+    event: React.MouseEvent;
+    target: HTMLElement;
+};
+type ContextMenuLocationWithEvent = Partial<CellContextMenuLocation> & {
+    event: React.MouseEvent;
+    target: HTMLElement;
+};
+interface InfiniteTableSetupState<T> {
+    updatedAt: number;
+    brain: MatrixBrain;
+    headerBrain: MatrixBrain;
+    renderer: GridRenderer;
+    onRenderUpdater: SubscriptionCallback<Renderable>;
+    headerRenderer: GridRenderer;
+    headerOnRenderUpdater: SubscriptionCallback<Renderable>;
+    debugWarnings: Map<InfiniteTableDebugWarningKey, DebugWarningPayload>;
+    devToolsDetected: boolean;
+    forceBodyRerenderTimestamp: number;
+    lastRowToExpandRef: MutableRefObject<any | null>;
+    lastRowToCollapseRef: MutableRefObject<any | null>;
+    getDOMNodeForCell: (cellPos: CellPositionByIndex) => HTMLElement | null;
+    propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
+    columnsWhenInlineGroupRenderStrategy?: Record<string, InfiniteTableColumn<T>>;
+    domRef: MutableRefObject<HTMLDivElement | null>;
+    editingValueRef: MutableRefObject<any | null>;
+    scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
+    portalDOMRef: MutableRefObject<HTMLDivElement | null>;
+    focusDetectDOMRef: MutableRefObject<HTMLDivElement | null>;
+    activeCellIndicatorDOMRef: MutableRefObject<HTMLDivElement | null>;
+    onFlashingDurationCSSVarChange: SubscriptionCallback<number>;
+    flashingDurationCSSVarValue: number | null;
+    onRowHeightCSSVarChange: SubscriptionCallback<number>;
+    onRowDetailHeightCSSVarChange: SubscriptionCallback<number>;
+    onColumnMenuClick: SubscriptionCallback<{
+        target: HTMLElement | EventTarget;
+        column: InfiniteTableComputedColumn<T>;
+    }>;
+    onFilterOperatorMenuClick: SubscriptionCallback<{
+        target: HTMLElement | EventTarget;
+        column: InfiniteTableComputedColumn<T>;
+    }>;
+    cellContextMenu: SubscriptionCallback<CellContextMenuLocationWithEvent>;
+    contextMenu: SubscriptionCallback<ContextMenuLocationWithEvent>;
+    cellContextMenuVisibleFor: CellContextMenuLocation | null;
+    contextMenuVisibleFor: (Partial<CellContextMenuLocation> & {
+        point: PointCoords;
+    }) | null;
+    columnMenuVisibleForColumnId: string | null;
+    columnMenuTargetRef: MutableRefObject<HTMLElement | null>;
+    columnMenuVisibleKey: string | number;
+    filterOperatorMenuVisibleForColumnId: string | null;
+    onColumnHeaderHeightCSSVarChange: SubscriptionCallback<number>;
+    cellClick: SubscriptionCallback<CellPositionByIndex & {
+        event: MouseEvent;
+    }>;
+    cellMouseDown: SubscriptionCallback<CellPositionByIndex & {
+        event: MouseEvent;
+    }>;
+    keyDown: SubscriptionCallback<KeyboardEvent>;
+    columnsWhenGrouping?: InfiniteTablePropColumns<T>;
+    bodySize: Size;
+    focused: boolean;
+    ready: boolean;
+    columnReorderDragColumnId: false | string;
+    columnReorderInPageIndex: number | null;
+    columnVisibilityForGrouping: Record<string, false>;
+    focusedWithin: boolean;
+    scrollPosition: ScrollPosition;
+    pinnedStartScrollListener: ScrollListener;
+    pinnedEndScrollListener: ScrollListener;
+    editingCell: {
+        active: true;
+        accepted: false;
+        columnId: string;
+        value: any;
+        persisted: false;
+        initialValue: any;
         rowIndex: number;
-        colIndex: number;
+        primaryKey: any;
+    } | null | {
+        active: false;
+        columnId: string;
+        rowIndex: number;
+        value: any;
+        initialValue: any;
+        primaryKey?: any;
+        waiting: 'accept' | 'persist' | false;
+        accepted: boolean | Error;
+        persisted: boolean | Error;
+        cancelled?: boolean;
     };
-    protected renderCellAt(rowIndex: number, colIndex: number, cell: GridCellInterface, renderCell: TableRenderCellFn): void;
-    protected onMouseEnter: (rowIndex: number) => void;
-    private addHoverClass;
-    protected onMouseLeave: (rowIndex: number) => void;
-    private removeHoverClass;
-    protected updateHoverClassNamesForRow: (rowIndex: number) => void;
-    protected updateElementPosition: (cell: GridCellInterface<{
-        renderRowIndex: number;
-        renderColIndex: number;
-    }>, options?: {
-        hidden: boolean;
-        rowspan: number;
-        colspan: number;
-    }) => void;
-    private updateDetailElementPosition;
-    private onScrollStart;
-    private onScrollStop;
-    adjustFixedElementsOnScroll: (scrollPosition?: ScrollPosition) => void;
-    destroy: () => void;
-    reset(): void;
+}
+type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
+type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
+type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
+interface InfiniteTableMappedState<T> {
+    id: InfiniteTableProps<T>['id'];
+    debugId: InfiniteTableProps<T>['debugId'];
+    scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
+    multiSortBehavior: NonUndefined<InfiniteTableProps<T>['multiSortBehavior']>;
+    viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
+    resizableColumns: InfiniteTableProps<T>['resizableColumns'];
+    groupColumn: InfiniteTableProps<T>['groupColumn'];
+    onKeyDown: InfiniteTableProps<T>['onKeyDown'];
+    onCellClick: InfiniteTableProps<T>['onCellClick'];
+    onCellDoubleClick: InfiniteTableProps<T>['onCellDoubleClick'];
+    onRowMouseEnter: InfiniteTableProps<T>['onRowMouseEnter'];
+    onRowMouseLeave: InfiniteTableProps<T>['onRowMouseLeave'];
+    repeatWrappedGroupRows: InfiniteTableProps<T>['repeatWrappedGroupRows'];
+    wrapRowsHorizontally: InfiniteTableProps<T>['wrapRowsHorizontally'];
+    rowDetailCache: RowDetailCache<RowDetailCacheKey, RowDetailCacheEntry>;
+    headerOptions: NonUndefined<InfiniteTableProps<T>['headerOptions']>;
+    draggableColumnsRestrictTo: NonUndefined<InfiniteTableProps<T>['draggableColumnsRestrictTo']>;
+    onScrollbarsChange: InfiniteTableProps<T>['onScrollbarsChange'];
+    getContextMenuItems: InfiniteTableProps<T>['getContextMenuItems'];
+    getCellContextMenuItems: InfiniteTableProps<T>['getCellContextMenuItems'];
+    getColumnMenuItems: InfiniteTableProps<T>['getColumnMenuItems'];
+    getFilterOperatorMenuItems: InfiniteTableProps<T>['getFilterOperatorMenuItems'];
+    keyboardShortcuts: InfiniteTableProps<T>['keyboardShortcuts'];
+    columnPinning: InfiniteTablePropColumnPinning;
+    loadingText: InfiniteTableProps<T>['loadingText'];
+    components: InfiniteTableProps<T>['components'];
+    columns: InfiniteTablePropColumns<T>;
+    pivotColumns: InfiniteTableProps<T>['pivotColumns'];
+    onReady: InfiniteTableProps<T>['onReady'];
+    onContextMenu: InfiniteTableProps<T>['onContextMenu'];
+    onCellContextMenu: InfiniteTableProps<T>['onCellContextMenu'];
+    onSelfFocus: InfiniteTableProps<T>['onSelfFocus'];
+    onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
+    onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
+    onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
+    onEditCancelled: InfiniteTableProps<T>['onEditCancelled'];
+    onEditRejected: InfiniteTableProps<T>['onEditRejected'];
+    onEditAccepted: InfiniteTableProps<T>['onEditAccepted'];
+    shouldAcceptEdit: InfiniteTableProps<T>['shouldAcceptEdit'];
+    persistEdit: InfiniteTableProps<T>['persistEdit'];
+    onEditPersistSuccess: InfiniteTableProps<T>['onEditPersistSuccess'];
+    onEditPersistError: InfiniteTableProps<T>['onEditPersistError'];
+    autoSizeColumnsKey: InfiniteTableProps<T>['autoSizeColumnsKey'];
+    activeRowIndex: InfiniteTableProps<T>['activeRowIndex'];
+    activeCellIndex: InfiniteTableProps<T>['activeCellIndex'];
+    onRenderRangeChange: InfiniteTableProps<T>['onRenderRangeChange'];
+    scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
+    onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
+    onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
+    onScrollStop: InfiniteTableProps<T>['onScrollStop'];
+    scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
+    focusedClassName: InfiniteTableProps<T>['focusedClassName'];
+    focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
+    focusedStyle: InfiniteTableProps<T>['focusedStyle'];
+    focusedWithinStyle: InfiniteTableProps<T>['focusedWithinStyle'];
+    showSeparatePivotColumnForSingleAggregation: NonUndefined<InfiniteTableProps<T>['showSeparatePivotColumnForSingleAggregation']>;
+    domProps: InfiniteTableProps<T>['domProps'];
+    editable: InfiniteTableProps<T>['editable'];
+    columnMenuRealignDelay: NonUndefined<InfiniteTableProps<T>['columnMenuRealignDelay']>;
+    columnDefaultEditable: InfiniteTableProps<T>['columnDefaultEditable'];
+    columnDefaultFilterable: InfiniteTableProps<T>['columnDefaultFilterable'];
+    columnDefaultGroupable: InfiniteTableProps<T>['columnDefaultGroupable'];
+    columnDefaultSortable: InfiniteTableProps<T>['columnDefaultSortable'];
+    rowStyle: InfiniteTableProps<T>['rowStyle'];
+    cellStyle: InfiniteTableProps<T>['cellStyle'];
+    rowProps: InfiniteTableProps<T>['rowProps'];
+    rowClassName: InfiniteTableProps<T>['rowClassName'];
+    rowHoverClassName: InfiniteTableProps<T>['rowHoverClassName'];
+    cellClassName: InfiniteTableProps<T>['cellClassName'];
+    pinnedStartMaxWidth: InfiniteTableProps<T>['pinnedStartMaxWidth'];
+    pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
+    pivotColumn: InfiniteTableProps<T>['pivotColumn'];
+    pivotColumnGroups: InfiniteTablePropColumnGroups;
+    columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
+    columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
+    columnDefaultWidth: NonUndefined<InfiniteTableProps<T>['columnDefaultWidth']>;
+    columnDefaultFlex: InfiniteTableProps<T>['columnDefaultFlex'];
+    columnCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnCssEllipsis']>;
+    draggableColumns: InfiniteTableProps<T>['draggableColumns'];
+    columnDefaultDraggable: InfiniteTableProps<T>['columnDefaultDraggable'];
+    sortable: InfiniteTableProps<T>['sortable'];
+    hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
+    hideColumnWhenGrouped: NonUndefined<InfiniteTableProps<T>['hideColumnWhenGrouped']>;
+    keyboardSelection: NonUndefined<InfiniteTableProps<T>['keyboardSelection']>;
+    columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
+    showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
+    showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
+    header: NonUndefined<InfiniteTableProps<T>['header']>;
+    virtualizeColumns: NonUndefined<InfiniteTableProps<T>['virtualizeColumns']>;
+    rowHeight: number | ((rowInfo: InfiniteTableRowInfo<T>) => number);
+    rowDetailHeight: number | ((rowInfo: InfiniteTableRowInfo<T>) => number);
+    columnHeaderHeight: number;
+    licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
+    columnVisibility: InfiniteTablePropColumnVisibility;
+    columnGroupVisibility: NonUndefined<InfiniteTableProps<T>['columnGroupVisibility']>;
+    columnSizing: InfiniteTablePropColumnSizing;
+    columnTypes: InfiniteTablePropColumnTypes<T>;
+    columnGroups: InfiniteTablePropColumnGroups;
+    collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
+    pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
+    pivotGrandTotalColumnPosition: InfiniteTableProps<T>['pivotGrandTotalColumnPosition'];
+}
+interface InfiniteTableDerivedState<T> {
+    isTree: boolean;
+    groupBy: DataSourceProps<T>['groupBy'];
+    computedColumns: Record<string, InfiniteTableColumn<T>>;
+    initialColumns: InfiniteTableProps<T>['columns'];
+    rowDetailState: RowDetailState<T> | undefined;
+    isRowDetailExpanded: InfiniteTableProps<T>['isRowDetailExpanded'] | undefined;
+    rowDetailRenderer?: InfiniteTableProps<T>['rowDetailRenderer'];
+    isRowDetailEnabled: NonUndefined<InfiniteTableProps<T>['isRowDetailEnabled']> | boolean;
+    showColumnFilters: NonUndefined<InfiniteTableProps<T>['showColumnFilters']>;
+    groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
+    columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
+    keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>;
+    columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
+    columnGroupsMaxDepth: number;
+    computedColumnGroups: InfiniteTablePropColumnGroups;
+    rowHeightCSSVar: string;
+    rowDetailHeightCSSVar: string;
+    columnHeaderHeightCSSVar: string;
+    controlledColumnVisibility: boolean;
+}
+type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
+interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
 }
 
-type CellPositionByIndex = {
+type CellPositionOptions = {
+    rowIndex: number;
+    colIndex: number;
+    rowId?: never;
+    colId?: never;
+} | {
+    rowIndex?: never;
+    colIndex?: never;
+    rowId: any;
+    colId: string;
+} | {
     rowIndex: number;
+    colIndex?: never;
+    rowId?: never;
+    colId: string;
+} | {
+    rowIndex?: never;
     colIndex: number;
+    rowId: any;
+    colId?: never;
 };
-type MultiSelectRangeOptions = {
-    horizontalLayout: false;
-} | {
-    horizontalLayout: true;
-    rowsPerPage: number;
-    columnsPerSet: number;
+
+type InfiniteTableCellSelectionApi<T> = {
+    isCellSelected(cellPosition: CellPositionOptions): boolean;
+    selectCell(cellPosition: CellPositionOptions & {
+        clear?: boolean;
+    }): void;
+    deselectCell(cellPosition: CellPositionOptions): void;
+    deselectAll(): void;
+    clear(): void;
+    selectAll(): void;
+    selectColumn(colId: string, options?: {
+        clear?: boolean;
+    }): void;
+    deselectColumn(colId: string): void;
+    selectRange(start: CellPositionOptions, end: CellPositionOptions): void;
+    deselectRange(start: CellPositionOptions, end: CellPositionOptions): void;
+    getAllCellSelectionPositions(): {
+        columnIds: string[];
+        positions: (CellSelectionPosition | null)[][];
+    };
+    mapCellSelectionPositions<SELECTED_VALUE, EMPTY_VALUE>(fn: (rowInfo: InfiniteTableRowInfo<T>, colId: string) => SELECTED_VALUE, emptyValue: EMPTY_VALUE): {
+        columnIds: string[];
+        positions: (SELECTED_VALUE | EMPTY_VALUE)[][];
+    };
 };
 
-declare class ScrollListener {
-    private scrollPosition;
-    private onScrollFns;
-    getScrollPosition: () => ScrollPosition;
-    onScroll: (fn: OnScrollFn) => () => void;
-    setScrollPosition: (scrollPosition: ScrollPosition) => void;
-    private notifyScrollChange;
-    destroy: () => void;
+type CellNavigationConfig = {
+    direction: 'top' | 'bottom' | 'left' | 'right';
+};
+interface InfiniteTableKeyboardNavigationApi<T> {
+    setKeyboardNavigation: (keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>) => void;
+    setActiveCellIndex: (activeCellIndex: NonUndefined<InfiniteTableProps<T>['activeCellIndex']>) => void;
+    setActiveRowIndex: (activeRowIndex: NonUndefined<InfiniteTableProps<T>['activeRowIndex']>) => void;
+    gotoNextRow: () => number | false;
+    gotoPreviousRow: () => number | false;
+    gotoRow: (direction: 1 | -1) => number | false;
+    gotoCell: (config: CellNavigationConfig) => false | [number, number];
 }
 
-type CellContextMenuLocation = {
-    rowId: any;
-    rowIndex: number;
-    columnId: string;
-    colIndex: number;
+type InfiniteTableRowDetailApi = {
+    isRowDetailExpanded(pk: any): boolean;
+    isRowDetailCollapsed(pk: any): boolean;
+    expandRowDetail(pk: any): void;
+    collapseRowDetail(pk: any): void;
+    toggleRowDetail(pk: any): void;
+    collapseAllDetails(): void;
+    expandAllDetails(): void;
+    isRowDetailEnabledForRow(pk: any): boolean;
 };
-type CellContextMenuLocationWithEvent = CellContextMenuLocation & {
-    event: React.MouseEvent;
-    target: HTMLElement;
+
+type RowSelectionStateItem = (any | any[])[];
+type RowSelectionStateObject = {
+    selectedRows: RowSelectionStateItem;
+    deselectedRows: RowSelectionStateItem;
+    defaultSelection: boolean;
+} | {
+    defaultSelection: true;
+    deselectedRows: RowSelectionStateItem;
+    selectedRows?: RowSelectionStateItem;
+} | {
+    defaultSelection: false;
+    selectedRows: RowSelectionStateItem;
+    deselectedRows?: RowSelectionStateItem;
 };
-type ContextMenuLocationWithEvent = Partial<CellContextMenuLocation> & {
-    event: React.MouseEvent;
-    target: HTMLElement;
+type RowSelectionStateConfig<T> = {
+    groupBy: DataSourceState<T>['groupBy'];
+    groupDeepMap: DataSourceState<T>['groupDeepMap'];
+    toPrimaryKey: DataSourceState<T>['toPrimaryKey'];
+    totalCount: number;
+    indexer: DataSourceState<T>['indexer'];
+    lazyLoad: boolean;
+    onlyUsePrimaryKeys: boolean;
 };
-interface InfiniteTableSetupState<T> {
-    brain: MatrixBrain;
-    headerBrain: MatrixBrain;
-    renderer: GridRenderer;
-    onRenderUpdater: SubscriptionCallback<Renderable>;
-    headerRenderer: GridRenderer;
-    headerOnRenderUpdater: SubscriptionCallback<Renderable>;
-    debugWarnings: Map<InfiniteTableDebugWarningKey, DebugWarningPayload>;
-    devToolsDetected: boolean;
-    forceBodyRerenderTimestamp: number;
-    lastRowToExpandRef: MutableRefObject<any | null>;
-    lastRowToCollapseRef: MutableRefObject<any | null>;
-    getDOMNodeForCell: (cellPos: CellPositionByIndex) => HTMLElement | null;
-    propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
-    columnsWhenInlineGroupRenderStrategy?: Record<string, InfiniteTableColumn<T>>;
-    domRef: MutableRefObject<HTMLDivElement | null>;
-    editingValueRef: MutableRefObject<any | null>;
-    scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
-    portalDOMRef: MutableRefObject<HTMLDivElement | null>;
-    focusDetectDOMRef: MutableRefObject<HTMLDivElement | null>;
-    activeCellIndicatorDOMRef: MutableRefObject<HTMLDivElement | null>;
-    onFlashingDurationCSSVarChange: SubscriptionCallback<number>;
-    flashingDurationCSSVarValue: number | null;
-    onRowHeightCSSVarChange: SubscriptionCallback<number>;
-    onRowDetailHeightCSSVarChange: SubscriptionCallback<number>;
-    onColumnMenuClick: SubscriptionCallback<{
-        target: HTMLElement | EventTarget;
-        column: InfiniteTableComputedColumn<T>;
-    }>;
-    onFilterOperatorMenuClick: SubscriptionCallback<{
-        target: HTMLElement | EventTarget;
-        column: InfiniteTableComputedColumn<T>;
-    }>;
-    cellContextMenu: SubscriptionCallback<CellContextMenuLocationWithEvent>;
-    contextMenu: SubscriptionCallback<ContextMenuLocationWithEvent>;
-    cellContextMenuVisibleFor: CellContextMenuLocation | null;
-    contextMenuVisibleFor: (Partial<CellContextMenuLocation> & {
-        point: PointCoords;
-    }) | null;
-    columnMenuVisibleForColumnId: string | null;
-    columnMenuTargetRef: MutableRefObject<HTMLElement | null>;
-    columnMenuVisibleKey: string | number;
-    filterOperatorMenuVisibleForColumnId: string | null;
-    onColumnHeaderHeightCSSVarChange: SubscriptionCallback<number>;
-    cellClick: SubscriptionCallback<CellPositionByIndex & {
-        event: MouseEvent;
-    }>;
-    cellMouseDown: SubscriptionCallback<CellPositionByIndex & {
-        event: MouseEvent;
+type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
+type RowSelectionStateOverride = {
+    getGroupKeysForPrimaryKey: RowSelectionState<any>['getGroupKeysForPrimaryKey'];
+    getGroupByLength: RowSelectionState<any>['getGroupByLength'];
+    getGroupCount: RowSelectionState<any>['getGroupCount'];
+    getGroupKeysDirectlyInsideGroup: RowSelectionState<any>['getGroupKeysDirectlyInsideGroup'];
+    getAllPrimaryKeysInsideGroup: RowSelectionState<any>['getAllPrimaryKeysInsideGroup'];
+};
+declare class RowSelectionState<T = any> {
+    selectedRows: RowSelectionStateItem | null;
+    deselectedRows: RowSelectionStateItem | null;
+    defaultSelection: boolean;
+    selectedMap: DeepMap<any, true>;
+    deselectedMap: DeepMap<any, true>;
+    onlyUsePrimaryKeys: boolean;
+    selectionCache: DeepMap<any, boolean | null>;
+    selectionCountCache: DeepMap<any, {
+        selectedCount: number;
+        deselectedCount: number;
     }>;
-    keyDown: SubscriptionCallback<KeyboardEvent>;
-    columnsWhenGrouping?: InfiniteTablePropColumns<T>;
-    bodySize: Size;
-    focused: boolean;
-    ready: boolean;
-    columnReorderDragColumnId: false | string;
-    columnReorderInPageIndex: number | null;
-    columnVisibilityForGrouping: Record<string, false>;
-    focusedWithin: boolean;
-    scrollPosition: ScrollPosition;
-    pinnedStartScrollListener: ScrollListener;
-    pinnedEndScrollListener: ScrollListener;
-    editingCell: {
-        active: true;
-        accepted: false;
-        columnId: string;
-        value: any;
-        persisted: false;
-        initialValue: any;
-        rowIndex: number;
-        primaryKey: any;
-    } | null | {
-        active: false;
-        columnId: string;
-        rowIndex: number;
-        value: any;
-        initialValue: any;
-        primaryKey?: any;
-        waiting: 'accept' | 'persist' | false;
-        accepted: boolean | Error;
-        persisted: boolean | Error;
-        cancelled?: boolean;
+    getConfig: GetRowSelectionStateConfig<T>;
+    getGroupKeysForPrimaryKey(pk: any): any[];
+    getGroupDeepMap(): DeepMap<any, DeepMapGroupValueType<T, any>> | undefined;
+    getGroupCount(groupKeys: any[]): number;
+    getGroupKeysDirectlyInsideGroup(groupKeys: any[]): any[][];
+    getAllPrimaryKeysInsideGroup(groupKeys: any[]): any[];
+    getGroupByLength(): number;
+    static from<T>(rowSeleStateObject: RowSelectionStateObject, getConfig: GetRowSelectionStateConfig<T>, overrides?: RowSelectionStateOverride): RowSelectionState<T>;
+    constructor(state: RowSelectionStateObject | RowSelectionState, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverride);
+    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;
+    };
+}
+
+type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
+type InfiniteTableRowSelectionApi = {
+    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(rowSelection?: RowSelectionStateObject): (string | number)[];
+    selectAll(): void;
+    deselectAll(): void;
+};
+
+declare enum InfiniteTableActionType {
+    SET_COLUMN_SIZE = 0,
+    SET_SCROLL_POSITION = 1,
+    SET_BODY_SIZE = 2,
+    SET_COLUMN_ORDER = 3,
+    SET_COLUMN_VISIBILITY = 4,
+    SET_COLUMN_SHIFTS = 5,
+    SET_COLUMN_PINNING = 6,
+    SET_COLUMN_AGGREGATIONS = 7,
+    SET_DRAGGING_COLUMN_ID = 8
+}
+
+type InfiniteTableAction = {
+    type: InfiniteTableActionType;
+    payload?: any;
+};
+
+declare class RowSizeCache {
+    rowHeight: Map<number, number>;
+    rowDetailHeight: Map<number, number>;
+    getTotalRowHeight(index: number): number;
+    getRowHeight: (index: number) => number;
+    getRowDetailHeight: (index: number) => number;
+    getSize(index: number): {
+        rowHeight: number;
+        rowDetailHeight: number;
+        totalRowHeight: number;
     };
 }
-type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
-type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
-type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
-interface InfiniteTableMappedState<T> {
-    id: InfiniteTableProps<T>['id'];
-    debugId: InfiniteTableProps<T>['debugId'];
-    scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
-    multiSortBehavior: NonUndefined<InfiniteTableProps<T>['multiSortBehavior']>;
-    viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
-    resizableColumns: InfiniteTableProps<T>['resizableColumns'];
-    groupColumn: InfiniteTableProps<T>['groupColumn'];
-    onKeyDown: InfiniteTableProps<T>['onKeyDown'];
-    onCellClick: InfiniteTableProps<T>['onCellClick'];
-    onCellDoubleClick: InfiniteTableProps<T>['onCellDoubleClick'];
-    onRowMouseEnter: InfiniteTableProps<T>['onRowMouseEnter'];
-    onRowMouseLeave: InfiniteTableProps<T>['onRowMouseLeave'];
-    repeatWrappedGroupRows: InfiniteTableProps<T>['repeatWrappedGroupRows'];
-    wrapRowsHorizontally: InfiniteTableProps<T>['wrapRowsHorizontally'];
-    rowDetailCache: RowDetailCache<RowDetailCacheKey, RowDetailCacheEntry>;
-    headerOptions: NonUndefined<InfiniteTableProps<T>['headerOptions']>;
-    draggableColumnsRestrictTo: NonUndefined<InfiniteTableProps<T>['draggableColumnsRestrictTo']>;
-    onScrollbarsChange: InfiniteTableProps<T>['onScrollbarsChange'];
-    getContextMenuItems: InfiniteTableProps<T>['getContextMenuItems'];
-    getCellContextMenuItems: InfiniteTableProps<T>['getCellContextMenuItems'];
-    getColumnMenuItems: InfiniteTableProps<T>['getColumnMenuItems'];
-    getFilterOperatorMenuItems: InfiniteTableProps<T>['getFilterOperatorMenuItems'];
-    keyboardShortcuts: InfiniteTableProps<T>['keyboardShortcuts'];
-    columnPinning: InfiniteTablePropColumnPinning;
-    loadingText: InfiniteTableProps<T>['loadingText'];
-    components: InfiniteTableProps<T>['components'];
-    columns: InfiniteTablePropColumns<T>;
-    pivotColumns: InfiniteTableProps<T>['pivotColumns'];
-    onReady: InfiniteTableProps<T>['onReady'];
-    onContextMenu: InfiniteTableProps<T>['onContextMenu'];
-    onCellContextMenu: InfiniteTableProps<T>['onCellContextMenu'];
-    onSelfFocus: InfiniteTableProps<T>['onSelfFocus'];
-    onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
-    onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
-    onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
-    onEditCancelled: InfiniteTableProps<T>['onEditCancelled'];
-    onEditRejected: InfiniteTableProps<T>['onEditRejected'];
-    onEditAccepted: InfiniteTableProps<T>['onEditAccepted'];
-    shouldAcceptEdit: InfiniteTableProps<T>['shouldAcceptEdit'];
-    persistEdit: InfiniteTableProps<T>['persistEdit'];
-    onEditPersistSuccess: InfiniteTableProps<T>['onEditPersistSuccess'];
-    onEditPersistError: InfiniteTableProps<T>['onEditPersistError'];
-    autoSizeColumnsKey: InfiniteTableProps<T>['autoSizeColumnsKey'];
-    activeRowIndex: InfiniteTableProps<T>['activeRowIndex'];
-    activeCellIndex: InfiniteTableProps<T>['activeCellIndex'];
-    onRenderRangeChange: InfiniteTableProps<T>['onRenderRangeChange'];
-    scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
-    onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
-    onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
-    onScrollStop: InfiniteTableProps<T>['onScrollStop'];
-    scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
-    focusedClassName: InfiniteTableProps<T>['focusedClassName'];
-    focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
-    focusedStyle: InfiniteTableProps<T>['focusedStyle'];
-    focusedWithinStyle: InfiniteTableProps<T>['focusedWithinStyle'];
-    showSeparatePivotColumnForSingleAggregation: NonUndefined<InfiniteTableProps<T>['showSeparatePivotColumnForSingleAggregation']>;
-    domProps: InfiniteTableProps<T>['domProps'];
-    editable: InfiniteTableProps<T>['editable'];
-    columnMenuRealignDelay: NonUndefined<InfiniteTableProps<T>['columnMenuRealignDelay']>;
-    columnDefaultEditable: InfiniteTableProps<T>['columnDefaultEditable'];
-    columnDefaultFilterable: InfiniteTableProps<T>['columnDefaultFilterable'];
-    columnDefaultGroupable: InfiniteTableProps<T>['columnDefaultGroupable'];
-    columnDefaultSortable: InfiniteTableProps<T>['columnDefaultSortable'];
-    rowStyle: InfiniteTableProps<T>['rowStyle'];
-    cellStyle: InfiniteTableProps<T>['cellStyle'];
-    rowProps: InfiniteTableProps<T>['rowProps'];
-    rowClassName: InfiniteTableProps<T>['rowClassName'];
-    rowHoverClassName: InfiniteTableProps<T>['rowHoverClassName'];
-    cellClassName: InfiniteTableProps<T>['cellClassName'];
-    pinnedStartMaxWidth: InfiniteTableProps<T>['pinnedStartMaxWidth'];
-    pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
-    pivotColumn: InfiniteTableProps<T>['pivotColumn'];
-    pivotColumnGroups: InfiniteTablePropColumnGroups;
-    columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
-    columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
-    columnDefaultWidth: NonUndefined<InfiniteTableProps<T>['columnDefaultWidth']>;
-    columnDefaultFlex: InfiniteTableProps<T>['columnDefaultFlex'];
-    columnCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnCssEllipsis']>;
-    draggableColumns: InfiniteTableProps<T>['draggableColumns'];
-    columnDefaultDraggable: InfiniteTableProps<T>['columnDefaultDraggable'];
-    sortable: InfiniteTableProps<T>['sortable'];
-    hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
-    hideColumnWhenGrouped: NonUndefined<InfiniteTableProps<T>['hideColumnWhenGrouped']>;
-    keyboardSelection: NonUndefined<InfiniteTableProps<T>['keyboardSelection']>;
-    columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
-    showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
-    showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
-    header: NonUndefined<InfiniteTableProps<T>['header']>;
-    virtualizeColumns: NonUndefined<InfiniteTableProps<T>['virtualizeColumns']>;
-    rowHeight: number | ((rowInfo: InfiniteTableRowInfo<T>) => number);
-    rowDetailHeight: number | ((rowInfo: InfiniteTableRowInfo<T>) => number);
-    columnHeaderHeight: number;
-    licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
-    columnVisibility: InfiniteTablePropColumnVisibility;
-    columnGroupVisibility: NonUndefined<InfiniteTableProps<T>['columnGroupVisibility']>;
-    columnSizing: InfiniteTablePropColumnSizing;
-    columnTypes: InfiniteTablePropColumnTypes<T>;
-    columnGroups: InfiniteTablePropColumnGroups;
-    collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
-    pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
-    pivotGrandTotalColumnPosition: InfiniteTableProps<T>['pivotGrandTotalColumnPosition'];
+
+type MultiCellSelectorOptions = {
+    getPrimaryKeyByIndex: (rowIndex: number) => string | number;
+    getColumnIdByIndex: (colIndex: number) => string;
+};
+declare class MultiCellSelector {
+    multiSelectStartPosition: CellPositionByIndex;
+    multiSelectEndPosition?: CellPositionByIndex;
+    getPrimaryKeyByIndex: MultiCellSelectorOptions['getPrimaryKeyByIndex'];
+    getColumnIdByIndex: MultiCellSelectorOptions['getColumnIdByIndex'];
+    _cellSelectionState: CellSelectionState;
+    constructor(options: MultiCellSelectorOptions);
+    private getCellSelectionPosition;
+    set cellSelectionState(cellSelectionState: CellSelectionState);
+    get cellSelectionState(): CellSelectionState;
+    /**
+     * This is the single click, without any modifier
+     */
+    resetClick(position: CellPositionByIndex): void;
+    /**
+     * This is the click with ctrl/cmd key pressed
+     * @param position CellPosition
+     */
+    singleAddClick(position: CellPositionByIndex): void;
+    multiSelectClick(position: CellPositionByIndex, options: MultiSelectRangeOptions): void;
+    setRangeSelected(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, selected: boolean, options: MultiSelectRangeOptions): void;
+    deselectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
+    selectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
 }
-interface InfiniteTableDerivedState<T> {
-    isTree: boolean;
-    groupBy: DataSourceProps<T>['groupBy'];
-    computedColumns: Record<string, InfiniteTableColumn<T>>;
-    initialColumns: InfiniteTableProps<T>['columns'];
-    rowDetailState: RowDetailState<T> | undefined;
-    isRowDetailExpanded: InfiniteTableProps<T>['isRowDetailExpanded'] | undefined;
-    rowDetailRenderer?: InfiniteTableProps<T>['rowDetailRenderer'];
-    isRowDetailEnabled: NonUndefined<InfiniteTableProps<T>['isRowDetailEnabled']> | boolean;
-    showColumnFilters: NonUndefined<InfiniteTableProps<T>['showColumnFilters']>;
-    groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
-    columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
-    keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>;
-    columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
-    columnGroupsMaxDepth: number;
-    computedColumnGroups: InfiniteTablePropColumnGroups;
-    rowHeightCSSVar: string;
-    rowDetailHeightCSSVar: string;
-    columnHeaderHeightCSSVar: string;
-    controlledColumnVisibility: boolean;
+
+type MultiRowSelectorOptions = {
+    getIdForIndex: (index: number) => string | number;
+    isRowDisabledAt: (index: number) => boolean;
+};
+declare class MultiRowSelector {
+    getIdForIndex: MultiRowSelectorOptions['getIdForIndex'];
+    isRowDisabledAt: MultiRowSelectorOptions['isRowDisabledAt'];
+    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;
 }
-type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
-interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
+
+interface InfiniteTableComputedValues<T> {
+    scrollbars: {
+        vertical: boolean;
+        horizontal: boolean;
+    };
+    multiRowSelector: MultiRowSelector;
+    multiCellSelector: MultiCellSelector;
+    computedRowHeight: number | ((index: number) => number);
+    computedRowSizeCacheForDetails: RowSizeCache | undefined;
+    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>>;
+    computedColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
+    computedColumnsMapInInitialOrder: Map<string, InfiniteTableComputedColumn<T>>;
+    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
+    computedPinnedStartColumnsWidth: number;
+    computedPinnedStartWidth: number;
+    computedPinnedEndColumnsWidth: number;
+    computedPinnedEndWidth: number;
+    computedUnpinnedColumnsWidth: number;
+    computedUnpinnedOffset: number;
+    computedPinnedEndOffset: number;
+    computedRemainingSpace: number;
+    fieldsToColumn: Map<keyof T, InfiniteTableComputedColumn<T>>;
+    toggleGroupRow: (groupKeys: any[]) => void;
+    columnSize: (colIndex: number) => number;
 }
 
-type CellPositionOptions = {
+type InfiniteTableEventHandlerContext<T> = {
+    getComputed: () => InfiniteTableComputedValues<T>;
+    getState: () => InfiniteTableState<T>;
+    actions: InfiniteTableActions<T>;
+    cloneRowSelection: (rowSelection: RowSelectionState<T>) => RowSelectionState<T>;
+    cloneTreeSelection: (treeSelection: TreeSelectionState<T>) => TreeSelectionState<T>;
+    getDataSourceState: () => DataSourceState<T>;
+    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
+    dataSourceActions: DataSourceComponentActions<T>;
+    api: InfiniteTableApi<T>;
+    dataSourceApi: DataSourceApi<T>;
+};
+type InfiniteTableKeyboardEventHandlerContext<T> = InfiniteTableEventHandlerContext<T>;
+type InfiniteTableCellClickEventHandlerContext<T> = InfiniteTableEventHandlerContext<T> & {
     rowIndex: number;
     colIndex: number;
-    rowId?: never;
-    colId?: never;
-} | {
-    rowIndex?: never;
-    colIndex?: never;
-    rowId: any;
-    colId: string;
-} | {
+    column: InfiniteTableComputedColumn<T>;
+    columnApi: InfiniteTableColumnApi<T>;
+};
+
+type OnCellClickContext<T> = InfiniteTableCellClickEventHandlerContext<T> & InfiniteTableKeyboardEventHandlerContext<T>;
+
+interface InfiniteTableContextValue<T> {
+    children?: React.ReactNode;
+    api: InfiniteTableApi<T>;
+    dataSourceApi: DataSourceApi<T>;
+    state: InfiniteTableState<T>;
+    actions: InfiniteTableActions<T>;
+    dataSourceActions: DataSourceComponentActions<T>;
+    computed: InfiniteTableComputedValues<T>;
+    getComputed: () => InfiniteTableComputedValues<T>;
+    getState: () => InfiniteTableState<T>;
+    getDataSourceState: () => DataSourceState<T>;
+    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
+}
+interface InfiniteTablePublicContext<T> {
+    api: InfiniteTableApi<T>;
+    dataSourceApi: DataSourceApi<T>;
+    getState: () => InfiniteTableState<T>;
+    getDataSourceState: () => DataSourceState<T>;
+}
+type InfiniteTableRowContext<T> = InfiniteTablePublicContext<T> & InfiniteTableRowInfoDataDiscriminator<T> & {
     rowIndex: number;
-    colIndex?: never;
-    rowId?: never;
-    colId: string;
-} | {
-    rowIndex?: never;
-    colIndex: number;
-    rowId: any;
-    colId?: never;
 };
+interface InfiniteTableCellContext<T> {
+    rowIndex: OnCellClickContext<T>['rowIndex'];
+    colIndex: OnCellClickContext<T>['colIndex'];
+    column: InfiniteTableComputedColumn<T>;
+    columnApi: InfiniteTableColumnApi<T>;
+}
+
+type ValueGetterParams<T> = {
+    data: T;
+    field?: keyof T;
+};
+type GroupKeyType$1<T extends any = any> = T;
+type GroupByValueGetter<T> = (params: ValueGetterParams<T>) => any;
+type GroupBy<DataType, KeyType = any> = {
+    toKey?: (value: any, data: DataType) => GroupKeyType$1<KeyType>;
+    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
+} & AllXOR<[
+    {
+        field: KeyOfNoSymbol<DataType>;
+    },
+    {
+        valueGetter: GroupByValueGetter<DataType>;
+        field: KeyOfNoSymbol<DataType>;
+    },
+    {
+        valueGetter: GroupByValueGetter<DataType>;
+        field?: KeyOfNoSymbol<DataType>;
+        groupField: string;
+    }
+]>;
+
+type SortDir = 1 | -1;
+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 | 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;
+};
+type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
+    field?: keyof T | (keyof T | ((item: T) => any))[];
+};
+declare const multisort: {
+    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options?: {
+        marker?: PerfMarker;
+        get?: (item: any) => T;
+    } | ((item: any) => T)): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
+};
+type NestedMultiSortOptions<T> = {
+    get?: (item: any) => T;
+    nodesKey: string;
+    isLeafNode?: (item: T) => boolean;
+    getNodeChildren?: (item: T) => null | T[];
+    toKey: (item: T) => any;
+    depthFirst?: boolean;
+    inplace?: boolean;
+    marker?: PerfMarker;
+};
+declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];
+
+type ForceOptions = {
+    force?: boolean;
+};
+type TreeExpandStateApi<T> = {
+    isNodeExpanded(nodePath: any[]): boolean;
+    isNodeReadOnly(nodePath: any[]): boolean;
+    expandNode(nodePath: any[], options?: ForceOptions): void;
+    collapseNode(nodePath: any[], options?: ForceOptions): void;
+    toggleNode(nodePath: any[], options?: ForceOptions): void;
+    getNodeDataByPath(nodePath: any[]): T | null;
+    getRowInfoByPath(nodePath: any[]): InfiniteTableRowInfo<T> | null;
+};
+type TreeSelectionApi<T = any> = {
+    get allRowsSelected(): boolean;
+    isNodeSelected(nodePath: NodePath$1): boolean | null;
+    selectNode(nodePath: NodePath$1, options?: ForceOptions): void;
+    setNodeSelection(nodePath: NodePath$1, selected: boolean, options?: ForceOptions): void;
+    deselectNode(nodePath: NodePath$1, options?: ForceOptions): void;
+    toggleNodeSelection(nodePath: NodePath$1, options?: ForceOptions): void;
+    selectAll(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    deselectAll(): void;
+    getSelectedLeafNodePaths(config?: {
+        rootNodePath?: NodePath$1;
+        treeSelectionState?: TreeSelectionState<T>;
+    }): NodePath$1[];
+    getDeselectedLeafNodePaths(config?: {
+        rootNodePath?: NodePath$1;
+        treeSelectionState?: TreeSelectionState<T>;
+    }): NodePath$1[];
+    getSelectedLeafRowInfos(config?: {
+        rootNodePath?: NodePath$1;
+        treeSelectionState?: TreeSelectionState<T>;
+    }): InfiniteTable_Tree_RowInfoLeafNode<T>[];
+};
+type TreeApi<T> = TreeExpandStateApi<T> & TreeSelectionApi<T>;
+
+type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
+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;
+}
+
+type IndexerOptions<DataType, PrimaryKeyType> = {
+    toPrimaryKey: (data: DataType) => PrimaryKeyType;
+    cache?: DataSourceCache<DataType, PrimaryKeyType>;
+    getNodeChildren?: TreeParams<DataType, PrimaryKeyType>['getNodeChildren'];
+    isLeafNode?: TreeParams<DataType, PrimaryKeyType>['isLeafNode'];
+    nodesKey: string | undefined;
+};
+declare class Indexer<DataType, PrimaryKeyType = string> {
+    primaryKeyToData: Map<PrimaryKeyType, DataType>;
+    nodePathsToData: DeepMap<PrimaryKeyType, DataType>;
+    private removeNodePath;
+    private remove;
+    private add;
+    private addNodePath;
+    clear: () => void;
+    getDataForPrimaryKey: (primaryKey: PrimaryKeyType) => DataType | undefined;
+    getDataForNodePath: (nodePath: NodePath$1) => DataType | undefined;
+    indexArray: (arr: DataType[], options: IndexerOptions<DataType, PrimaryKeyType>) => DataType[];
+}
+
+declare class RowDisabledState<KeyType = any> extends BooleanCollectionState<RowDisabledStateObject<KeyType>, KeyType> {
+    constructor(state: RowDisabledStateObject<KeyType> | RowDisabledState<KeyType>);
+    getState(): RowDisabledStateObject<KeyType>;
+    getPositiveFromState(state: RowDisabledStateObject<KeyType>): true | KeyType[];
+    getNegativeFromState(state: RowDisabledStateObject<KeyType>): true | KeyType[];
+    areAllDisabled(): boolean;
+    areAllEnabled(): boolean;
+    disableAll(): void;
+    enableAll(): void;
+    isRowEnabled: (key: KeyType) => boolean;
+    isRowDisabled(key: KeyType): boolean;
+    setRowEnabled(key: KeyType, enabled: boolean): void;
+    disableRow(key: KeyType): void;
+    enableRow(key: KeyType): void;
+    toggleRow(key: KeyType): void;
+}
 
-type InfiniteTableCellSelectionApi<T> = {
-    isCellSelected(cellPosition: CellPositionOptions): boolean;
-    selectCell(cellPosition: CellPositionOptions & {
-        clear?: boolean;
-    }): void;
-    deselectCell(cellPosition: CellPositionOptions): void;
-    deselectAll(): void;
-    clear(): void;
-    selectAll(): void;
-    selectColumn(colId: string, options?: {
-        clear?: boolean;
-    }): void;
-    deselectColumn(colId: string): void;
-    selectRange(start: CellPositionOptions, end: CellPositionOptions): void;
-    deselectRange(start: CellPositionOptions, end: CellPositionOptions): void;
-    getAllCellSelectionPositions(): {
-        columnIds: string[];
-        positions: (CellSelectionPosition | null)[][];
-    };
-    mapCellSelectionPositions<SELECTED_VALUE, EMPTY_VALUE>(fn: (rowInfo: InfiniteTableRowInfo<T>, colId: string) => SELECTED_VALUE, emptyValue: EMPTY_VALUE): {
-        columnIds: string[];
-        positions: (SELECTED_VALUE | EMPTY_VALUE)[][];
-    };
+interface DataSourceDataParams<T> {
+    originalDataArray: T[];
+    masterRowInfo?: InfiniteTableRowInfo<any>;
+    sortInfo?: DataSourceSortInfo<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    filterValue?: DataSourcePropFilterValue<T>;
+    refetchKey?: DataSourceProps<T>['refetchKey'];
+    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
+    lazyLoadBatchSize?: number;
+    lazyLoadStartIndex?: number;
+    groupKeys?: any[];
+    append?: boolean;
+    aggregationReducers?: DataSourcePropAggregationReducers<T>;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    __cursorId?: DataSourceSetupState<T>['cursorId'];
+    changes?: DataSourceDataParamsChanges<T>;
+}
+type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
+type DataSourceSingleSortInfo<T> = MultisortInfoAllowMultipleFields<T> & {
+    id?: string;
 };
-
-type CellNavigationConfig = {
-    direction: 'top' | 'bottom' | 'left' | 'right';
+type DataSourceGroupBy<T> = GroupBy<T, any>;
+type DataSourcePivotBy<T> = PivotBy<T, any>;
+type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
+type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
+type DataSourceRemoteData<T> = {
+    data: T[] | LazyGroupDataItem<T>[];
+    mappings?: DataSourceMappings;
+    cache?: boolean;
+    error?: string;
+    totalCount?: number;
+    totalCountUnfiltered?: number;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
 };
-interface InfiniteTableKeyboardNavigationApi<T> {
-    setKeyboardNavigation: (keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>) => void;
-    setActiveCellIndex: (activeCellIndex: NonUndefined<InfiniteTableProps<T>['activeCellIndex']>) => void;
-    setActiveRowIndex: (activeRowIndex: NonUndefined<InfiniteTableProps<T>['activeRowIndex']>) => void;
-    gotoNextRow: () => number | false;
-    gotoPreviousRow: () => number | false;
-    gotoRow: (direction: 1 | -1) => number | false;
-    gotoCell: (config: CellNavigationConfig) => false | [number, number];
+type DataSourceDataFn<T> = (dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>;
+type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | DataSourceDataFn<T>;
+type DataSourceGroupRowsList<KeyType = any> = true | KeyType[][];
+type DataSourcePropGroupRowsStateObject<KeyType = any> = {
+    expandedRows: DataSourceGroupRowsList<KeyType>;
+    collapsedRows: DataSourceGroupRowsList<KeyType>;
+};
+type DataSourcePropGroupRowsState<KeyType = any> = GroupRowsState<KeyType> | DataSourcePropGroupRowsStateObject<KeyType>;
+type RowDetailStateObject<KeyType = any> = {
+    expandedRows: true | KeyType[];
+    collapsedRows: true | KeyType[];
+};
+type RowDisabledStateObject<KeyType = any> = {
+    enabledRows: true;
+    disabledRows: KeyType[];
+} | {
+    disabledRows: true;
+    enabledRows: KeyType[];
+};
+type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
+type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
+interface DataSourceMappedState<T> {
+    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
+    livePagination: DataSourceProps<T>['livePagination'];
+    refetchKey: NonUndefined<DataSourceProps<T>['refetchKey']>;
+    isRowSelected: DataSourceProps<T>['isRowSelected'];
+    isNodeSelected: TreeDataSourceProps<T>['isNodeSelected'];
+    isNodeExpanded: TreeDataSourceProps<T>['isNodeExpanded'];
+    isNodeCollapsed: TreeDataSourceProps<T>['isNodeCollapsed'];
+    isNodeReadOnly: NonUndefined<TreeDataSourceProps<T>['isNodeReadOnly']>;
+    isNodeSelectable: NonUndefined<TreeDataSourceProps<T>['isNodeSelectable']>;
+    onNodeCollapse: TreeDataSourceProps<T>['onNodeCollapse'];
+    onNodeExpand: TreeDataSourceProps<T>['onNodeExpand'];
+    isRowDisabled: DataSourceProps<T>['isRowDisabled'];
+    nodesKey: NonUndefined<TreeDataSourceProps<T>['nodesKey']>;
+    treeSelection: TreeDataSourceProps<T>['treeSelection'];
+    batchOperationDelay: DataSourceProps<T>['batchOperationDelay'];
+    onDataArrayChange: DataSourceProps<T>['onDataArrayChange'];
+    onDataMutations: DataSourceProps<T>['onDataMutations'];
+    onTreeDataMutations: TreeDataSourceProps<T>['onTreeDataMutations'];
+    onReady: DataSourceProps<T>['onReady'];
+    rowInfoReducers: DataSourceProps<T>['rowInfoReducers'];
+    lazyLoad: DataSourceProps<T>['lazyLoad'];
+    useGroupKeysForMultiRowSelection: NonUndefined<DataSourceProps<T>['useGroupKeysForMultiRowSelection']>;
+    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
+    data: DataSourceProps<T>['data'];
+    sortFunction: DataSourceProps<T>['sortFunction'];
+    filterFunction: DataSourceProps<T>['filterFunction'];
+    treeFilterFunction: DataSourceProps<T>['treeFilterFunction'];
+    filterValue: DataSourceProps<T>['filterValue'];
+    filterTypes: NonUndefined<DataSourceProps<T>['filterTypes']>;
+    primaryKey: DataSourceProps<T>['primaryKey'];
+    filterDelay: NonUndefined<DataSourceProps<T>['filterDelay']>;
+    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
+    pivotBy: DataSourceProps<T>['pivotBy'];
+    loading: NonUndefined<DataSourceProps<T>['loading']>;
+    sortTypes: NonUndefined<DataSourceProps<T>['sortTypes']>;
+    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
+    sortInfo: DataSourceSingleSortInfo<T>[] | null;
+    rowDisabledState: RowDisabledState<T> | null;
 }
-
-type InfiniteTableRowDetailApi = {
-    isRowDetailExpanded(pk: any): boolean;
-    isRowDetailCollapsed(pk: any): boolean;
-    expandRowDetail(pk: any): void;
-    collapseRowDetail(pk: any): void;
-    toggleRowDetail(pk: any): void;
-    collapseAllDetails(): void;
-    expandAllDetails(): void;
-    isRowDetailEnabledForRow(pk: any): boolean;
+type DataSourceRawReducer<T, RESULT_TYPE> = {
+    initialValue?: RESULT_TYPE | (() => RESULT_TYPE);
+    reducer: (accumulator: any, value: T) => RESULT_TYPE;
+    done?: (accumulatedValue: RESULT_TYPE, array: T[]) => RESULT_TYPE;
 };
-
-type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
-type InfiniteTableRowSelectionApi = {
-    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(rowSelection?: RowSelectionStateObject): (string | number)[];
-    selectAll(): void;
-    deselectAll(): void;
+type DataSourceAggregationReducer<T, AggregationResultType> = {
+    name?: string;
+    field?: keyof T;
+    initialValue?: AggregationResultType | (() => any);
+    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 enum InfiniteTableActionType {
-    SET_COLUMN_SIZE = 0,
-    SET_SCROLL_POSITION = 1,
-    SET_BODY_SIZE = 2,
-    SET_COLUMN_ORDER = 3,
-    SET_COLUMN_VISIBILITY = 4,
-    SET_COLUMN_SHIFTS = 5,
-    SET_COLUMN_PINNING = 6,
-    SET_COLUMN_AGGREGATIONS = 7,
-    SET_DRAGGING_COLUMN_ID = 8
+type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
+    inheritFromColumn?: string | boolean;
+};
+type DataSourceMappings = Record<'totals' | 'values', string>;
+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>;
+    };
+};
+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;
+};
+type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
+type DebugTimingKey = 'group-and-pivot' | 'filter' | 'sort' | 'pivot' | 'tree';
+interface DataSourceSetupState<T> {
+    logger: DebugLogger;
+    forceRerenderTimestamp: number;
+    devToolsDetected: boolean;
+    rowInfoStore: RowInfoStore<T>;
+    debugTimings: Map<DebugTimingKey, number>;
+    debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
+    indexer: Indexer<T, any>;
+    getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
+    __apiRef: React$1.MutableRefObject<DataSourceApi<T> | null>;
+    lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<{
+        nodePath: NodePath$1;
+        selected: boolean;
+    } | null>;
+    lastExpandStateInfoRef: React$1.MutableRefObject<{
+        state: 'collapsed' | 'expanded';
+        nodePath: NodePath$1 | null;
+    }>;
+    waitForNodePathPromises: DeepMap<any, {
+        timestamp: number;
+        promise: Promise<boolean>;
+        resolve: (value: boolean) => void;
+    }>;
+    repeatWrappedGroupRows: InfiniteTablePropRepeatWrappedGroupRows<T>;
+    /**
+     * This is just used for horizontal layout and when repeatWrappedGroupRows is TRUE!!!
+     */
+    rowsPerPage: number | null;
+    totalLeafNodesCount: number;
+    destroyedRef: React$1.MutableRefObject<boolean>;
+    idToIndexMap: Map<any, number>;
+    idToPathMap: Map<any, NodePath$1>;
+    pathToIndexMap: DeepMap<any, number>;
+    detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+    treeSelectionState?: TreeSelectionState;
+    stateReadyAsDetails: boolean;
+    cache?: DataSourceCache<T>;
+    unfilteredCount: number;
+    filteredCount: number;
+    rowInfoReducerResults?: Record<string, any>;
+    originalDataArrayChanged: boolean;
+    originalDataArrayChangedInfo: {
+        timestamp: number;
+        mutations?: Map<string, DataSourceMutation<T>[]>;
+        treeMutations?: DeepMap<any, DataSourceMutation<T>[]>;
+    };
+    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;
+    onCleanup: SubscriptionCallback<DataSourceState<T>>;
+    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
+    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
+    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
+    originalDataArray: T[];
+    lastFilterDataArray?: T[];
+    lastSortDataArray?: T[];
+    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
+    lastTreeDataArray?: InfiniteTableRowInfo<T>[];
+    dataArray: InfiniteTableRowInfo<T>[];
+    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
+    treeDeepMap?: DeepMap<TreeKeyType, DeepMapTreeValueType<T, any>>;
+    treePaths?: DeepMap<TreeKeyType, true>;
+    unfilteredTreePaths?: DeepMap<TreeKeyType, true>;
+    groupRowsIndexesInDataArray?: number[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
+    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
+    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
+    updatedAt: number;
+    reducedAt: number;
+    groupedAt: number;
+    treeAt: number;
+    sortedAt: number;
+    filteredAt: number;
+    generateGroupRows: boolean;
+    postFilterDataArray?: T[];
+    postSortDataArray?: T[];
+    postGroupDataArray?: InfiniteTableRowInfo<T>[];
+    pivotColumns?: Record<string, InfiniteTableColumn<T>>;
+    pivotColumnGroups?: Record<string, InfiniteTableColumnGroup>;
 }
+type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
+type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
+type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
+type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
+type TreeSelectionValue = TreeSelectionStateObject | TreeSelectionState;
 
-type InfiniteTableAction = {
-    type: InfiniteTableActionType;
-    payload?: any;
+type DataSourcePropTreeSelection_MultiNode = TreeSelectionValue;
+type DataSourcePropRowSelection_SingleRow = null | string | number;
+type DataSourcePropTreeSelection_SingleNode = null | string | number;
+type DataSourcePropTreeSelection = DataSourcePropTreeSelection_MultiNode | DataSourcePropTreeSelection_SingleNode;
+type DataSourcePropCellSelection_MultiCell = CellSelectionStateObject | CellSelectionState;
+type DataSourcePropCellSelection_SingleCell = null | CellSelectionPosition;
+type DataSourcePropCellSelection = DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
+type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
+type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
+type DataSourcePropOnTreeSelectionChange_MultiNode<T = any> = (treeSelectionStateObject: TreeSelectionStateObject, params: {
+    treeSelectionState: TreeSelectionState<T>;
+    prevTreeSelectionState: TreeSelectionState<T>;
+    unfilteredTreePaths: DeepMap<TreeKeyType, true>;
+    selectionMode: 'multi-row';
+    lastUpdatedNodeInfo: {
+        nodePath: NodePath$1;
+        selected: boolean;
+    } | null;
+    dataSourceApi: DataSourceApi<T>;
+    treeApi: TreeApi<T>;
+}) => void;
+type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
+type DataSourcePropOnTreeSelectionChange_SingleNode = (treeSelection: DataSourcePropTreeSelection_SingleNode, params: {
+    selectionMode: 'single-row';
+}) => void;
+type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
+type DataSourcePropOnTreeSelectionChange = DataSourcePropOnTreeSelectionChange_SingleNode | DataSourcePropOnTreeSelectionChange_MultiNode;
+type DataSourcePropOnCellSelectionChange_MultiCell = (cellSelection: DataSourcePropCellSelection_MultiCell, selectionMode: 'multi-cell') => void;
+type DataSourcePropOnCellSelectionChange_SingleCell = (cellSelection: DataSourcePropCellSelection_SingleCell, selectionMode: 'single-cell') => void;
+type DataSourcePropOnCellSelectionChange = DataSourcePropOnCellSelectionChange_MultiCell | DataSourcePropOnCellSelectionChange_SingleCell;
+type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
+type DataSourcePropIsNodeReadOnly<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>) => boolean;
+type DataSourcePropIsNodeSelected<T> = (rowInfo: InfiniteTable_Tree_RowInfoNode<T>, treeSelectionState: TreeSelectionState, selectionMode: 'multi-row') => boolean | null;
+type DataSourcePropIsNodeSelectable<T> = (rowInfo: InfiniteTable_Tree_RowInfoNode<T>) => boolean;
+type DataSourcePropIsNodeExpanded<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>, treeExpandState: TreeExpandState) => boolean;
+type DataSourcePropSortFn<T> = (sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: (item: any) => T) => T[];
+type DataSourceCRUDParam = {
+    flush?: boolean;
+    metadata?: any;
 };
-
-declare class RowSizeCache {
-    rowHeight: Map<number, number>;
-    rowDetailHeight: Map<number, number>;
-    getTotalRowHeight(index: number): number;
-    getRowHeight: (index: number) => number;
-    getRowDetailHeight: (index: number) => number;
-    getSize(index: number): {
-        rowHeight: number;
-        rowDetailHeight: number;
-        totalRowHeight: number;
-    };
+type WaitForNodeOptions = {
+    waitForNode?: boolean | number;
+};
+type DataSourceUpdateParam = DataSourceCRUDParam & WaitForNodeOptions;
+type DataSourceInsertParam = DataSourceCRUDParam & WaitForNodeOptions & ({
+    position: 'before' | 'after';
+    primaryKey: any;
+    nodePath?: never;
+} | {
+    position: 'before' | 'after';
+    primaryKey?: never;
+    nodePath: NodePath$1;
+} | {
+    position: 'start' | 'end';
+    nodePath?: never;
+} | {
+    position: 'start' | 'end';
+    nodePath: NodePath$1;
+});
+type UpdateChildrenFn<T> = (dataChildren: T[] | undefined | null, data: T) => T[] | undefined | null;
+interface DataSourceApi<T> {
+    getPendingOperationPromise(): Promise<boolean> | null;
+    getOriginalDataArray: () => T[];
+    getRowInfoArray: () => InfiniteTableRowInfo<T>[];
+    getDataByPrimaryKey(id: any): T | null;
+    getDataByNodePath(nodePath: NodePath$1): T | null;
+    getDataByIndex(index: number): T | null;
+    getRowInfoByIndex(index: number): InfiniteTableRowInfo<T> | null;
+    getRowInfoByPrimaryKey(id: any): InfiniteTableRowInfo<T> | null;
+    getRowInfoByNodePath(nodePath: NodePath$1): InfiniteTableRowInfo<T> | null;
+    getIndexByPrimaryKey(id: any): number;
+    getIndexByNodePath(nodePath: NodePath$1): number;
+    getPrimaryKeyByIndex(id: any): any;
+    getNodePathById(id: any): NodePath$1 | null;
+    getNodePathByIndex(index: number): NodePath$1 | null;
+    get treeApi(): TreeApi<T>;
+    /**
+     * @param nodePath The node path to wait for
+     * @param options
+     * @param options.timeout The timeout to wait for the node path to be available. Defaults to 1000ms.
+     *
+     * @returns true if the path is already in the DataSource, otherwise a promise resolving to a boolean value.
+     * If the timeout is reached and the path is not available, the promise is resolved to false. Otherwise, the promise is resolved to true.
+     */
+    waitForNodePath(nodePath: NodePath$1, options?: {
+        timeout?: number;
+    }): Promise<boolean>;
+    isNodePathAvailable(nodePath: NodePath$1): boolean;
+    updateData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
+    updateDataByNodePath(data: Partial<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
+    updateChildrenByNodePath(childrenOrFn: T[] | undefined | null | UpdateChildrenFn<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
+    updateDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
+    updateDataArrayByNodePath(updateInfo: {
+        data: Partial<T>;
+        nodePath: NodePath$1;
+    }[], options?: DataSourceUpdateParam): Promise<any>;
+    flush(): Promise<any>;
+    removeDataByPrimaryKey(id: any, options?: DataSourceCRUDParam): Promise<any>;
+    removeDataByNodePath(nodePath: NodePath$1, options?: DataSourceCRUDParam): Promise<any>;
+    removeDataArrayByPrimaryKeys(id: any[], options?: DataSourceCRUDParam): Promise<any>;
+    removeData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
+    removeDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
+    clearAllData(options?: DataSourceCRUDParam): Promise<any>;
+    replaceAllData(data: T[], options?: DataSourceCRUDParam): Promise<any>;
+    addData(data: T, options?: DataSourceCRUDParam): Promise<any>;
+    addDataArray(data: T[], options?: DataSourceCRUDParam): Promise<any>;
+    insertData(data: T, options: DataSourceInsertParam): Promise<any>;
+    insertDataArray(data: T[], options: DataSourceInsertParam): Promise<any>;
+    setSortInfo(sortInfo: null | DataSourceSingleSortInfo<T>[]): void;
+    isRowDisabledAt: (rowIndex: number) => boolean;
+    isRowDisabled: (primaryKey: any) => boolean;
+    setRowEnabledAt: (rowIndex: number, enabled: boolean) => void;
+    setRowEnabled: (primaryKey: any, enabled: boolean) => void;
+    enableAllRows: () => void;
+    disableAllRows: () => void;
+    areAllRowsEnabled: () => boolean;
+    areAllRowsDisabled: () => boolean;
+    setGroupBy: (groupBy: DataSourceState<T>['groupBy']) => void;
+    toggleGroupByField: (field: keyof T) => void;
 }
-
-type MultiCellSelectorOptions = {
-    getPrimaryKeyByIndex: (rowIndex: number) => string | number;
-    getColumnIdByIndex: (colIndex: number) => string;
+type DataSourcePropRowInfoReducers<T> = Record<string, DataSourceRowInfoReducer<T>>;
+type DataSourceRowInfoReducer<T> = DataSourceRawReducer<InfiniteTableRowInfo<T>, any>;
+type DataSourcePropShouldReloadDataObject<T> = {
+    [key in keyof Pick<DataSourceDataParams<T>, 'sortInfo' | 'pivotBy' | 'groupBy' | 'filterValue'>]: boolean;
 };
-declare class MultiCellSelector {
-    multiSelectStartPosition: CellPositionByIndex;
-    multiSelectEndPosition?: CellPositionByIndex;
-    getPrimaryKeyByIndex: MultiCellSelectorOptions['getPrimaryKeyByIndex'];
-    getColumnIdByIndex: MultiCellSelectorOptions['getColumnIdByIndex'];
-    _cellSelectionState: CellSelectionState;
-    constructor(options: MultiCellSelectorOptions);
-    private getCellSelectionPosition;
-    set cellSelectionState(cellSelectionState: CellSelectionState);
-    get cellSelectionState(): CellSelectionState;
+type DataSourcePropShouldReloadData<T> = DataSourcePropShouldReloadDataObject<T> | boolean;
+type TreeExpandStateValue = TreeExpandState | TreeExpandStateObject<any>;
+type DataSourceProps<T> = {
+    nodesKey?: never;
+    debugId?: string;
+    children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
+    primaryKey: keyof T | ((data: T) => string);
     /**
-     * This is the single click, without any modifier
+     * @deprecated for now
      */
-    resetClick(position: CellPositionByIndex): void;
+    fields?: (keyof T)[];
+    refetchKey?: number | string | object;
+    batchOperationDelay?: number;
+    rowInfoReducers?: DataSourcePropRowInfoReducers<T>;
+    data: DataSourceData<T>;
+    selectionMode?: DataSourcePropSelectionMode;
+    useGroupKeysForMultiRowSelection?: boolean;
+    rowSelection?: DataSourcePropRowSelection;
+    defaultRowSelection?: DataSourcePropRowSelection;
+    cellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
+    defaultCellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange;
+    rowDisabledState?: RowDisabledState | RowDisabledStateObject<any>;
+    defaultRowDisabledState?: RowDisabledState | RowDisabledStateObject<any>;
+    onRowDisabledStateChange?: (rowDisabledState: RowDisabledState) => void;
+    isRowDisabled?: (rowInfo: InfiniteTableRowInfo<T>) => boolean;
+    isRowSelected?: DataSourcePropIsRowSelected<T>;
+    lazyLoad?: boolean | {
+        batchSize?: number;
+    };
+    loading?: boolean;
+    defaultLoading?: boolean;
+    onLoadingChange?: (loading: boolean) => void;
+    onReady?: (api: DataSourceApi<T>) => 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?: DataSourcePropGroupRowsState<any>;
+    defaultGroupRowsState?: DataSourcePropGroupRowsState<any>;
+    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
+    collapseGroupRowsOnDataFunctionChange?: boolean;
+    sortFunction?: DataSourcePropSortFn<T>;
+    sortInfo?: DataSourceSortInfo<T>;
+    defaultSortInfo?: DataSourceSortInfo<T>;
+    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
+    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
+    onDataArrayChange?: (dataArray: DataSourceState<T>['originalDataArray'], info: DataSourceState<T>['originalDataArrayChangedInfo']) => void;
+    onDataMutations?: ({ dataArray, timestamp, mutations, primaryKeyField, }: {
+        primaryKeyField: undefined | keyof T;
+        dataArray: DataSourceState<T>['originalDataArray'];
+        timestamp: number;
+        mutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['mutations']>;
+    }) => void;
+    livePagination?: boolean;
+    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
+    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
+    filterFunction?: DataSourcePropFilterFunction<T>;
+    treeFilterFunction?: DataSourcePropTreeFilterFunction<T>;
     /**
-     * This is the click with ctrl/cmd key pressed
-     * @param position CellPosition
+     * @deprecated Use shouldReloadData.sortInfo instead
      */
-    singleAddClick(position: CellPositionByIndex): void;
-    multiSelectClick(position: CellPositionByIndex, options: MultiSelectRangeOptions): void;
-    setRangeSelected(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, selected: boolean, options: MultiSelectRangeOptions): void;
-    deselectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
-    selectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
-}
-
-type MultiRowSelectorOptions = {
-    getIdForIndex: (index: number) => string | number;
-    isRowDisabledAt: (index: number) => boolean;
-};
-declare class MultiRowSelector {
-    getIdForIndex: MultiRowSelectorOptions['getIdForIndex'];
-    isRowDisabledAt: MultiRowSelectorOptions['isRowDisabledAt'];
-    multiSelectStartIndex: number;
-    multiSelectEndIndex?: number;
-    _rowSelectionState: RowSelectionState;
-    constructor(options: MultiRowSelectorOptions);
-    set rowSelectionState(rowSelectionState: RowSelectionState);
-    get rowSelectionState(): RowSelectionState;
-    private selectRange;
-    private deselectRange;
+    sortMode?: 'local' | 'remote';
     /**
-     * This is the single click, without any modifier
+     * @deprecated Use shouldReloadData.filterValue instead
      */
-    resetClick(index: number): void;
+    filterMode?: 'local' | 'remote';
     /**
-     * This is the click with ctrl/cmd key pressed
-     * @param index
+     * @deprecated Use shouldReloadData.groupBy instead
      */
-    singleAddClick(index: number): void;
-    multiSelectClick(index: number): void;
-}
-
-interface InfiniteTableComputedValues<T> {
-    scrollbars: {
-        vertical: boolean;
-        horizontal: boolean;
+    groupMode?: 'local' | 'remote';
+    shouldReloadData?: DataSourcePropShouldReloadData<T>;
+    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';
+    cellSelection?: DataSourcePropCellSelection_SingleCell;
+    defaultCellSelection?: DataSourcePropCellSelection_SingleCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_SingleCell;
+} | {
+    selectionMode?: 'multi-cell';
+    cellSelection?: DataSourcePropCellSelection_MultiCell;
+    defaultCellSelection?: DataSourcePropCellSelection_MultiCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_MultiCell;
+} | {
+    selectionMode?: false;
+});
+/**
+ * @deprecated Use DataSourceProps<T> instead
+ */
+type DataSourcePropsWithChildren<T> = DataSourceProps<T> & {};
+type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
+type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
+type DataSourceFilterFunctionParam<T> = {
+    data: T;
+    index: number;
+    dataArray: T[];
+    primaryKey: any;
+};
+type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
+type DataSourcePropTreeFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T> & {
+    filterTreeNode: (data: T) => T | boolean;
+}) => T | boolean;
+type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
+type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
+    field: keyof T;
+}, {
+    id: string;
+}> & {
+    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
+    filter: {
+        type: string;
+        operator: string;
+        value: any;
     };
-    multiRowSelector: MultiRowSelector;
-    multiCellSelector: MultiCellSelector;
-    computedRowHeight: number | ((index: number) => number);
-    computedRowSizeCacheForDetails: RowSizeCache | undefined;
-    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>>;
-    computedColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
-    computedColumnsMapInInitialOrder: Map<string, InfiniteTableComputedColumn<T>>;
-    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
-    computedPinnedStartColumnsWidth: number;
-    computedPinnedStartWidth: number;
-    computedPinnedEndColumnsWidth: number;
-    computedPinnedEndWidth: number;
-    computedUnpinnedColumnsWidth: number;
-    computedUnpinnedOffset: number;
-    computedPinnedEndOffset: number;
-    computedRemainingSpace: number;
-    fieldsToColumn: Map<keyof T, InfiniteTableComputedColumn<T>>;
-    toggleGroupRow: (groupKeys: any[]) => void;
-    columnSize: (colIndex: number) => number;
+    disabled?: boolean;
+};
+type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T> & {
+    field?: keyof T;
+}) => any;
+type DataSourceFilterType<T> = {
+    emptyValues: any[];
+    label?: string;
+    defaultOperator: string;
+    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
+    components?: {
+        FilterEditor?: () => React$1.JSX.Element | null;
+        FilterOperatorSwitch?: () => React$1.JSX.Element | null;
+    };
+    operators: DataSourceFilterOperator<T>[];
+};
+type DataSourceFilterOperator<T> = {
+    name: string;
+    label?: string;
+    components?: {
+        FilterEditor?: () => React$1.JSX.Element | null;
+        Icon?: (props: any) => React$1.JSX.Element | null;
+    };
+    fn: DataSourceFilterOperatorFunction<T>;
+    defaultFilterValue?: any;
+};
+type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
+type DataSourceFilterOperatorFunctionParam<T> = {
+    currentValue: any;
+    filterValue: any;
+    emptyValues: any[];
+    field?: keyof T;
+} & DataSourceFilterFunctionParam<T>;
+type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
+type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
+type DataSourceLivePaginationCursorParams<T> = {
+    array: T[];
+    lastItem: T | Partial<T> | null;
+    length: number;
+};
+type DataSourceLivePaginationCursorValue = string | number | null;
+interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
 }
-
-type InfiniteTableEventHandlerContext<T> = {
-    getComputed: () => InfiniteTableComputedValues<T>;
-    getState: () => InfiniteTableState<T>;
-    actions: InfiniteTableActions<T>;
-    cloneRowSelection: (rowSelection: RowSelectionState<T>) => RowSelectionState<T>;
-    cloneTreeSelection: (treeSelection: TreeSelectionState<T>) => TreeSelectionState<T>;
-    getDataSourceState: () => DataSourceState<T>;
-    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
-    dataSourceActions: DataSourceComponentActions<T>;
-    api: InfiniteTableApi<T>;
+type DataSourceCallback_BaseParam<T> = {
     dataSourceApi: DataSourceApi<T>;
 };
-type InfiniteTableKeyboardEventHandlerContext<T> = InfiniteTableEventHandlerContext<T>;
-type InfiniteTableCellClickEventHandlerContext<T> = InfiniteTableEventHandlerContext<T> & {
-    rowIndex: number;
-    colIndex: number;
-    column: InfiniteTableComputedColumn<T>;
-    columnApi: InfiniteTableColumnApi<T>;
+type DataSourceDerivedState<T> = {
+    debugId: DataSourceProps<T>['debugId'];
+    isTree: boolean;
+    toPrimaryKey: (data: T) => any;
+    operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
+    sortMode: 'local' | 'remote';
+    filterMode: 'local' | 'remote';
+    groupMode: 'local' | 'remote';
+    pivotMode: 'local' | 'remote';
+    shouldReloadData: NonUndefined<Required<DataSourcePropShouldReloadDataObject<T>>>;
+    groupRowsState: GroupRowsState<T>;
+    treeExpandState: TreeExpandState<any>;
+    treeExpandMode: TreeExpandStateMode;
+    multiSort: boolean;
+    controlledSort: boolean;
+    controlledFilter: boolean;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    lazyLoadBatchSize?: number;
+    rowSelection: RowSelectionState | null | number | string;
+    isRowDisabled: DataSourceProps<T>['isRowDisabled'];
+    cellSelection: CellSelectionState | null;
+    selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
 };
-
-type OnCellClickContext<T> = InfiniteTableCellClickEventHandlerContext<T> & InfiniteTableKeyboardEventHandlerContext<T>;
-
-interface InfiniteTableContextValue<T> {
-    children?: React.ReactNode;
-    api: InfiniteTableApi<T>;
-    dataSourceApi: DataSourceApi<T>;
-    state: InfiniteTableState<T>;
-    actions: InfiniteTableActions<T>;
-    dataSourceActions: DataSourceComponentActions<T>;
-    computed: InfiniteTableComputedValues<T>;
-    getComputed: () => InfiniteTableComputedValues<T>;
-    getState: () => InfiniteTableState<T>;
-    getDataSourceState: () => DataSourceState<T>;
-    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
+type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
+interface DataSourceContextValue<T> {
+    api: DataSourceApi<T>;
+    getState: () => DataSourceState<T>;
+    assignState: (state: Partial<DataSourceState<T>>) => void;
+    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue<any> | undefined;
+    componentState: DataSourceState<T>;
+    componentActions: DataSourceComponentActions<T>;
 }
-interface InfiniteTablePublicContext<T> {
-    api: InfiniteTableApi<T>;
-    dataSourceApi: DataSourceApi<T>;
-    getState: () => InfiniteTableState<T>;
-    getDataSourceState: () => DataSourceState<T>;
+interface DataSourceMasterDetailContextValue<MASTER_TYPE = any> {
+    registerDetail: (detail: DataSourceContextValue<any>) => void;
+    getMasterState: () => InfiniteTableState<MASTER_TYPE>;
+    getMasterDataSourceState: () => DataSourceState<MASTER_TYPE>;
+    shouldRestoreState: boolean;
+    masterRowInfo: InfiniteTableRowInfo<MASTER_TYPE>;
 }
-type InfiniteTableRowContext<T> = InfiniteTablePublicContext<T> & InfiniteTableRowInfoDataDiscriminator<T> & {
-    rowIndex: number;
-};
-interface InfiniteTableCellContext<T> {
-    rowIndex: OnCellClickContext<T>['rowIndex'];
-    colIndex: OnCellClickContext<T>['colIndex'];
-    column: InfiniteTableComputedColumn<T>;
-    columnApi: InfiniteTableColumnApi<T>;
+declare enum DataSourceActionType {
+    INIT = "INIT"
+}
+interface DataSourceAction<T> {
+    type: DataSourceActionType;
+    payload: T;
 }
 
 type InfiniteTableBaseCellProps<T> = {
@@ -3216,6 +3248,7 @@ type InfiniteTableBaseCellProps<T> = {
     afterChildren?: Renderable;
     cssPosition?: CSSProperties['position'];
     domRef?: React.RefCallback<HTMLElement>;
+    repaintId?: number | string;
 };
 type InfiniteTableCellProps<T> = ({
     cellType: 'header';
@@ -3416,6 +3449,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -3557,6 +3591,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -3698,6 +3733,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -3840,6 +3876,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -3981,6 +4018,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4122,6 +4160,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4264,6 +4303,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4405,6 +4445,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4546,6 +4587,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4688,6 +4730,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4829,6 +4872,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -4970,6 +5014,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -5112,6 +5157,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -5253,6 +5299,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -5394,6 +5441,7 @@ declare const useManagedDataSource: (props: object) => {
             logger: DebugLogger;
             forceRerenderTimestamp: number;
             devToolsDetected: never;
+            rowInfoStore: RowInfoStore<unknown>;
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
@@ -5537,6 +5585,7 @@ declare const useManagedDataSource: (props: object) => {
         logger: DebugLogger;
         forceRerenderTimestamp: number;
         devToolsDetected: never;
+        rowInfoStore: RowInfoStore<unknown>;
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
@@ -5678,6 +5727,7 @@ declare const useManagedDataSource: (props: object) => {
         logger: DebugLogger;
         forceRerenderTimestamp: number;
         devToolsDetected: never;
+        rowInfoStore: RowInfoStore<unknown>;
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
@@ -5819,6 +5869,7 @@ declare const useManagedDataSource: (props: object) => {
         logger: DebugLogger;
         forceRerenderTimestamp: number;
         devToolsDetected: never;
+        rowInfoStore: RowInfoStore<unknown>;
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
@@ -5960,6 +6011,7 @@ declare const useManagedDataSource: (props: object) => {
         logger: DebugLogger;
         forceRerenderTimestamp: number;
         devToolsDetected: never;
+        rowInfoStore: RowInfoStore<unknown>;
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
@@ -6101,6 +6153,7 @@ declare const useManagedDataSource: (props: object) => {
         logger: DebugLogger;
         forceRerenderTimestamp: number;
         devToolsDetected: never;
+        rowInfoStore: RowInfoStore<unknown>;
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
@@ -6242,6 +6295,7 @@ declare const useManagedDataSource: (props: object) => {
         logger: DebugLogger;
         forceRerenderTimestamp: number;
         devToolsDetected: never;
+        rowInfoStore: RowInfoStore<unknown>;
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;