@infinite-table/infinite-react 7.4.1 → 7.5.0-canary.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,2185 +1052,2183 @@ 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;
+    }): 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 DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<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 TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
-type TableRenderDetailRowFn = (param: TableRenderDetailRowFnParam) => Renderable;
-type RenderRangeOptions = {
-    force?: boolean;
-    renderCell: TableRenderCellFn;
-    renderDetailRow?: TableRenderDetailRowFn;
-    onRender: (items: Renderable[]) => void;
+type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'defaultSortable'> & {
+    groupByForColumn: GroupBy<T> | GroupBy<T>[];
+    id?: string;
 };
-type HorizontalLayoutColVisibilityOptions = {
-    horizontalLayoutPageIndex?: number;
+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 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): 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): 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> = {
@@ -3211,6 +3247,7 @@ type InfiniteTableBaseCellProps<T> = {
     afterChildren?: Renderable;
     cssPosition?: CSSProperties['position'];
     domRef?: React.RefCallback<HTMLElement>;
+    repaintId?: number | string;
 };
 type InfiniteTableCellProps<T> = ({
     cellType: 'header';
@@ -3411,6 +3448,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>;
@@ -3533,7 +3571,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -3552,6 +3590,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>;
@@ -3674,7 +3713,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -3693,6 +3732,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>;
@@ -3815,7 +3855,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -3835,6 +3875,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>;
@@ -3957,7 +3998,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -3976,6 +4017,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>;
@@ -4098,7 +4140,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4117,6 +4159,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>;
@@ -4239,7 +4282,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4259,6 +4302,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>;
@@ -4381,7 +4425,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4400,6 +4444,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>;
@@ -4522,7 +4567,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4541,6 +4586,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>;
@@ -4663,7 +4709,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4683,6 +4729,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>;
@@ -4805,7 +4852,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4824,6 +4871,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>;
@@ -4946,7 +4994,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -4965,6 +5013,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>;
@@ -5087,7 +5136,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -5107,6 +5156,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>;
@@ -5229,7 +5279,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -5248,6 +5298,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>;
@@ -5370,7 +5421,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -5389,6 +5440,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>;
@@ -5511,7 +5563,7 @@ declare const useManagedDataSource: (props: object) => {
             lazyLoad: never;
             useGroupKeysForMultiRowSelection: never;
             onDataParamsChange: never;
-            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
             sortFunction: never;
             filterFunction: never;
             treeFilterFunction: never;
@@ -5532,6 +5584,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>;
@@ -5654,7 +5707,7 @@ declare const useManagedDataSource: (props: object) => {
         lazyLoad: never;
         useGroupKeysForMultiRowSelection: never;
         onDataParamsChange: never;
-        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
         sortFunction: never;
         filterFunction: never;
         treeFilterFunction: never;
@@ -5673,6 +5726,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>;
@@ -5795,7 +5849,7 @@ declare const useManagedDataSource: (props: object) => {
         lazyLoad: never;
         useGroupKeysForMultiRowSelection: never;
         onDataParamsChange: never;
-        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
         sortFunction: never;
         filterFunction: never;
         treeFilterFunction: never;
@@ -5814,6 +5868,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>;
@@ -5936,7 +5991,7 @@ declare const useManagedDataSource: (props: object) => {
         lazyLoad: never;
         useGroupKeysForMultiRowSelection: never;
         onDataParamsChange: never;
-        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
         sortFunction: never;
         filterFunction: never;
         treeFilterFunction: never;
@@ -5955,6 +6010,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>;
@@ -6077,7 +6133,7 @@ declare const useManagedDataSource: (props: object) => {
         lazyLoad: never;
         useGroupKeysForMultiRowSelection: never;
         onDataParamsChange: never;
-        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
         sortFunction: never;
         filterFunction: never;
         treeFilterFunction: never;
@@ -6096,6 +6152,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>;
@@ -6218,7 +6275,7 @@ declare const useManagedDataSource: (props: object) => {
         lazyLoad: never;
         useGroupKeysForMultiRowSelection: never;
         onDataParamsChange: never;
-        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
         sortFunction: never;
         filterFunction: never;
         treeFilterFunction: never;
@@ -6237,6 +6294,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>;
@@ -6359,7 +6417,7 @@ declare const useManagedDataSource: (props: object) => {
         lazyLoad: never;
         useGroupKeysForMultiRowSelection: never;
         onDataParamsChange: never;
-        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
+        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & DataSourceDataFn<unknown>;
         sortFunction: never;
         filterFunction: never;
         treeFilterFunction: never;
@@ -7131,6 +7189,7 @@ interface InfiniteTableApi<T> {
     realignColumnContextMenu: () => void;
     getColumnOrder: () => string[];
     getVisibleColumnOrder: () => string[];
+    getVisibleRenderRange: () => TableRenderRange;
     getComputedColumnById: (colId: string) => InfiniteTableComputedColumn<T> | undefined;
     isEditorVisibleForCell(params: {
         rowIndex: number;
@@ -7715,4 +7774,4 @@ declare const components: {
     NumberFilterEditor: typeof NumberFilterEditor;
 };
 
-export { type AdvancedAlignable, CellSelectionState, type CellSelectionStateObject, type ColumnTypeWithInherit, DataClient, DataSource, type DataSourceAction, DataSourceActionType, type DataSourceAggregationReducer, type DataSourceApi, type DataSourceCRUDParam, type DataSourceCallback_BaseParam, type DataSourceComponentActions, type DataSourceContextValue, type DataSourceData, type DataSourceDataParams, type DataSourceDataParamsChanges, type DataSourceDebugWarningKey, type DataSourceDerivedState, type DataSourceFilterFunctionParam, type DataSourceFilterOperator, type DataSourceFilterOperatorFunction, type DataSourceFilterOperatorFunctionParam, type DataSourceFilterType, type DataSourceFilterValueItem, type DataSourceFilterValueItemValueGetter, type DataSourceGroupBy, type DataSourceGroupRowsList, type DataSourceInsertParam, type DataSourceLivePaginationCursorFn, type DataSourceLivePaginationCursorParams, type DataSourceLivePaginationCursorValue, type DataSourceMappedState, type DataSourceMappings, type DataSourceMasterDetailContextValue, type DataSourcePivotBy, type DataSourcePropAggregationReducers, type DataSourcePropCellSelection, type DataSourcePropCellSelection_MultiCell, type DataSourcePropCellSelection_SingleCell, type DataSourcePropFilterFunction, type DataSourcePropFilterTypes, type DataSourcePropFilterValue, type DataSourcePropGroupBy, type DataSourcePropGroupRowsState, type DataSourcePropGroupRowsStateObject, type DataSourcePropIsNodeExpanded, type DataSourcePropIsNodeReadOnly, type DataSourcePropIsNodeSelectable, type DataSourcePropIsNodeSelected, type DataSourcePropIsRowSelected, type DataSourcePropLivePaginationCursor, type DataSourcePropMultiRowSelectionChangeParamType, type DataSourcePropOnCellSelectionChange, type DataSourcePropOnCellSelectionChange_MultiCell, type DataSourcePropOnCellSelectionChange_SingleCell, type DataSourcePropOnRowSelectionChange, type DataSourcePropOnRowSelectionChange_MultiRow, type DataSourcePropOnRowSelectionChange_SingleRow, type DataSourcePropOnTreeSelectionChange, type DataSourcePropOnTreeSelectionChange_MultiNode, type DataSourcePropOnTreeSelectionChange_SingleNode, type DataSourcePropPivotBy, type DataSourcePropRowInfoReducers, type DataSourcePropRowSelection, type DataSourcePropRowSelection_MultiRow, type DataSourcePropRowSelection_SingleRow, type DataSourcePropSelectionMode, type DataSourcePropShouldReloadData, type DataSourcePropShouldReloadDataObject, type DataSourcePropSortFn, type DataSourcePropSortInfo, type DataSourcePropSortTypes, type DataSourcePropTreeFilterFunction, type DataSourcePropTreeSelection, type DataSourcePropTreeSelection_MultiNode, type DataSourcePropTreeSelection_SingleNode, type DataSourceProps, type DataSourcePropsNotAvailableInTreeDataSource, type DataSourcePropsWithChildren, type DataSourceRawReducer, type DataSourceRemoteData, type DataSourceRowInfoReducer, type DataSourceSetupState, type DataSourceSingleSortInfo, type DataSourceSortInfo, type DataSourceState, type DataSourceUpdateParam, type DebugLogger, type DebugTimingKey, type DebugWarningPayload, DeepMap, type DevToolsDataSourceOverrides, type DevToolsGenericMessage, type DevToolsHookFn, type DevToolsHookFnOptions, type DevToolsHostPageLogMessage, type DevToolsHostPageLogMessagePayload, type DevToolsHostPageMessage, type DevToolsHostPageMessagePayload, type DevToolsHostPageMessageType, type DevToolsInfiniteOverrides, type DevToolsMessageAddress, type DevToolsOverrides, type ElementContainerGetter, type ErrorCodeKey, FixedSizeSet, FlashingColumnCell, GroupRowsState, INTERNAL_MatrixDebugger, type InfiniteColumnEditorContextType, InfiniteTable, type InfiniteTableAction, InfiniteTableActionType, type InfiniteTableApi, type InfiniteTableCellSelectionApi, InfiniteTableClassName, type InfiniteTableColumn, type InfiniteTableColumnAggregator, type InfiniteTableColumnApi, type InfiniteTableColumnCellContextType, type InfiniteTableColumnComparer, type InfiniteTableColumnGroup, type InfiniteTableColumnRenderFunctionForGroupRows, type InfiniteTableColumnRenderFunctionForNormalRows, type InfiniteTableColumnRenderValueParam, type InfiniteTableColumnRowspanParam, type InfiniteTableColumnSizingOptions, type InfiniteTableColumnValueFormatterParams, type InfiniteTableColumnValueGetterParams, InfiniteTableComponent, type InfiniteTableComputedColumn, type InfiniteTableComputedValues, type InfiniteTableContextValue, type InfiniteTableDebugWarningKey, type InfiniteTableGroupColumnBase, type InfiniteTableGroupColumnFunction, type InfiniteTableGroupColumnGetterOptions, type InfiniteTableKeyboardNavigationApi, type InfiniteTablePivotColumn, type InfiniteTablePropAutoSizeColumnsKey, type InfiniteTablePropColumnGroupVisibility, type InfiniteTablePropColumnGroups, type InfiniteTablePropColumnOrder, type InfiniteTablePropColumnPinning, type InfiniteTablePropColumnSizing, type InfiniteTablePropColumnTypes, type InfiniteTablePropColumnVisibility, type InfiniteTablePropColumns, type InfiniteTablePropComponents, type InfiniteTablePropGetCellContextMenuItems, type InfiniteTablePropGetColumnMenuItems, type InfiniteTablePropGetContextMenuItems, type InfiniteTablePropGroupColumn, type InfiniteTablePropGroupRenderStrategy, type InfiniteTablePropHeaderOptions, type InfiniteTablePropKeyboardNavigation, type InfiniteTablePropKeyboardShorcut, type InfiniteTablePropMultiSortBehavior, type InfiniteTablePropRowClassName, type InfiniteTablePropRowStyle, type InfiniteTableProps, type InfiniteTablePropsNotAvailableInTreeGrid, type InfiniteTableRowClassNameFn, type InfiniteTableRowDetailApi, type InfiniteTableRowInfo, type InfiniteTableRowSelectionApi, type InfiniteTableRowStyleFn, type InfiniteTableState, type InfiniteTable_HasGrouping_RowInfoGroup, type InfiniteTable_HasGrouping_RowInfoNormal, type InfiniteTable_Tree_RowInfoLeafNode, type InfiniteTable_Tree_RowInfoNode, type InfiniteTable_Tree_RowInfoParentNode, type LazyGroupDataDeepMap, type LazyGroupDataItem, type LazyRowInfoGroup, Menu, type MenuChildrenFnParam, type MenuColumn, type MenuColumnRenderParam, type MenuDecoration, type MenuIconProps, type MenuItemActionContext, type MenuItemDefinition, type MenuItemObject, type MenuProps, type MenuRenderable, type MenuRuntimeItem, type MenuRuntimeItemSelectable, type MenuSeparator, type OverlayShowParams, RowDetailCache, RowDetailState, type RowDetailStateObject, RowDisabledState, type RowDisabledStateObject, RowSelectionState, type ScrollStopInfo, type Scrollbars, type ShowOverlayFn, type TableRenderRange, TreeDataSource, type TreeDataSourceProps, TreeExpandState, type TreeExpandStateValue, TreeGrid, type TreeGridOnlyProps, type TreeGridProps, TreeSelectionState, type TreeSelectionStateObject, type TreeSelectionValue, type UpdateChildrenFn, type UpdateOverlayContentFn, type WaitForNodeOptions, WeakFixedSizeSet, alignNode, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, filterDataArray, defaultFilterTypes as filterTypes, flatten, buildManagedComponent as getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, multisortNested, queryKeyToCacheKey, toTreeDataArray, useManagedComponentState as useComponentState, useDataSourceInternal, useDataSourceState, useEffectWhen, useEffectWhenSameDeps, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useInfinitePortalContainer, useLayoutEffectWithChanges, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes, withSelectedLeafNodesOnly };
+export { type AdvancedAlignable, CellSelectionState, type CellSelectionStateObject, type ColumnTypeWithInherit, DataClient, DataSource, type DataSourceAction, DataSourceActionType, type DataSourceAggregationReducer, type DataSourceApi, type DataSourceCRUDParam, type DataSourceCallback_BaseParam, type DataSourceComponentActions, type DataSourceContextValue, type DataSourceData, type DataSourceDataFn, type DataSourceDataParams, type DataSourceDataParamsChanges, type DataSourceDebugWarningKey, type DataSourceDerivedState, type DataSourceFilterFunctionParam, type DataSourceFilterOperator, type DataSourceFilterOperatorFunction, type DataSourceFilterOperatorFunctionParam, type DataSourceFilterType, type DataSourceFilterValueItem, type DataSourceFilterValueItemValueGetter, type DataSourceGroupBy, type DataSourceGroupRowsList, type DataSourceInsertParam, type DataSourceLivePaginationCursorFn, type DataSourceLivePaginationCursorParams, type DataSourceLivePaginationCursorValue, type DataSourceMappedState, type DataSourceMappings, type DataSourceMasterDetailContextValue, type DataSourcePivotBy, type DataSourcePropAggregationReducers, type DataSourcePropCellSelection, type DataSourcePropCellSelection_MultiCell, type DataSourcePropCellSelection_SingleCell, type DataSourcePropFilterFunction, type DataSourcePropFilterTypes, type DataSourcePropFilterValue, type DataSourcePropGroupBy, type DataSourcePropGroupRowsState, type DataSourcePropGroupRowsStateObject, type DataSourcePropIsNodeExpanded, type DataSourcePropIsNodeReadOnly, type DataSourcePropIsNodeSelectable, type DataSourcePropIsNodeSelected, type DataSourcePropIsRowSelected, type DataSourcePropLivePaginationCursor, type DataSourcePropMultiRowSelectionChangeParamType, type DataSourcePropOnCellSelectionChange, type DataSourcePropOnCellSelectionChange_MultiCell, type DataSourcePropOnCellSelectionChange_SingleCell, type DataSourcePropOnRowSelectionChange, type DataSourcePropOnRowSelectionChange_MultiRow, type DataSourcePropOnRowSelectionChange_SingleRow, type DataSourcePropOnTreeSelectionChange, type DataSourcePropOnTreeSelectionChange_MultiNode, type DataSourcePropOnTreeSelectionChange_SingleNode, type DataSourcePropPivotBy, type DataSourcePropRowInfoReducers, type DataSourcePropRowSelection, type DataSourcePropRowSelection_MultiRow, type DataSourcePropRowSelection_SingleRow, type DataSourcePropSelectionMode, type DataSourcePropShouldReloadData, type DataSourcePropShouldReloadDataObject, type DataSourcePropSortFn, type DataSourcePropSortInfo, type DataSourcePropSortTypes, type DataSourcePropTreeFilterFunction, type DataSourcePropTreeSelection, type DataSourcePropTreeSelection_MultiNode, type DataSourcePropTreeSelection_SingleNode, type DataSourceProps, type DataSourcePropsNotAvailableInTreeDataSource, type DataSourcePropsWithChildren, type DataSourceRawReducer, type DataSourceRemoteData, type DataSourceRowInfoReducer, type DataSourceSetupState, type DataSourceSingleSortInfo, type DataSourceSortInfo, type DataSourceState, type DataSourceUpdateParam, type DebugLogger, type DebugTimingKey, type DebugWarningPayload, DeepMap, type DevToolsDataSourceOverrides, type DevToolsGenericMessage, type DevToolsHookFn, type DevToolsHookFnOptions, type DevToolsHostPageLogMessage, type DevToolsHostPageLogMessagePayload, type DevToolsHostPageMessage, type DevToolsHostPageMessagePayload, type DevToolsHostPageMessageType, type DevToolsInfiniteOverrides, type DevToolsMessageAddress, type DevToolsOverrides, type ElementContainerGetter, type ErrorCodeKey, FixedSizeSet, FlashingColumnCell, GroupRowsState, INTERNAL_MatrixDebugger, type InfiniteColumnEditorContextType, InfiniteTable, type InfiniteTableAction, InfiniteTableActionType, type InfiniteTableApi, type InfiniteTableCellSelectionApi, InfiniteTableClassName, type InfiniteTableColumn, type InfiniteTableColumnAggregator, type InfiniteTableColumnApi, type InfiniteTableColumnCellContextType, type InfiniteTableColumnComparer, type InfiniteTableColumnGroup, type InfiniteTableColumnRenderFunctionForGroupRows, type InfiniteTableColumnRenderFunctionForNormalRows, type InfiniteTableColumnRenderValueParam, type InfiniteTableColumnRowspanParam, type InfiniteTableColumnSizingOptions, type InfiniteTableColumnValueFormatterParams, type InfiniteTableColumnValueGetterParams, InfiniteTableComponent, type InfiniteTableComputedColumn, type InfiniteTableComputedValues, type InfiniteTableContextValue, type InfiniteTableDebugWarningKey, type InfiniteTableGroupColumnBase, type InfiniteTableGroupColumnFunction, type InfiniteTableGroupColumnGetterOptions, type InfiniteTableKeyboardNavigationApi, type InfiniteTablePivotColumn, type InfiniteTablePropAutoSizeColumnsKey, type InfiniteTablePropColumnGroupVisibility, type InfiniteTablePropColumnGroups, type InfiniteTablePropColumnOrder, type InfiniteTablePropColumnPinning, type InfiniteTablePropColumnSizing, type InfiniteTablePropColumnTypes, type InfiniteTablePropColumnVisibility, type InfiniteTablePropColumns, type InfiniteTablePropComponents, type InfiniteTablePropGetCellContextMenuItems, type InfiniteTablePropGetColumnMenuItems, type InfiniteTablePropGetContextMenuItems, type InfiniteTablePropGroupColumn, type InfiniteTablePropGroupRenderStrategy, type InfiniteTablePropHeaderOptions, type InfiniteTablePropKeyboardNavigation, type InfiniteTablePropKeyboardShorcut, type InfiniteTablePropMultiSortBehavior, type InfiniteTablePropRowClassName, type InfiniteTablePropRowStyle, type InfiniteTableProps, type InfiniteTablePropsNotAvailableInTreeGrid, type InfiniteTableRowClassNameFn, type InfiniteTableRowDetailApi, type InfiniteTableRowInfo, type InfiniteTableRowSelectionApi, type InfiniteTableRowStyleFn, type InfiniteTableState, type InfiniteTable_HasGrouping_RowInfoGroup, type InfiniteTable_HasGrouping_RowInfoNormal, type InfiniteTable_Tree_RowInfoLeafNode, type InfiniteTable_Tree_RowInfoNode, type InfiniteTable_Tree_RowInfoParentNode, type LazyGroupDataDeepMap, type LazyGroupDataItem, type LazyRowInfoGroup, Menu, type MenuChildrenFnParam, type MenuColumn, type MenuColumnRenderParam, type MenuDecoration, type MenuIconProps, type MenuItemActionContext, type MenuItemDefinition, type MenuItemObject, type MenuProps, type MenuRenderable, type MenuRuntimeItem, type MenuRuntimeItemSelectable, type MenuSeparator, type OverlayShowParams, RowDetailCache, RowDetailState, type RowDetailStateObject, RowDisabledState, type RowDisabledStateObject, RowSelectionState, type ScrollStopInfo, type Scrollbars, type ShowOverlayFn, type TableRenderRange, TreeDataSource, type TreeDataSourceProps, TreeExpandState, type TreeExpandStateValue, TreeGrid, type TreeGridOnlyProps, type TreeGridProps, TreeSelectionState, type TreeSelectionStateObject, type TreeSelectionValue, type UpdateChildrenFn, type UpdateOverlayContentFn, type WaitForNodeOptions, WeakFixedSizeSet, alignNode, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, filterDataArray, defaultFilterTypes as filterTypes, flatten, buildManagedComponent as getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, multisortNested, queryKeyToCacheKey, toTreeDataArray, useManagedComponentState as useComponentState, useDataSourceInternal, useDataSourceState, useEffectWhen, useEffectWhenSameDeps, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useInfinitePortalContainer, useLayoutEffectWithChanges, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes, withSelectedLeafNodesOnly };