@infinite-table/infinite-react 6.2.11 → 7.0.0

package/index.d.ts

@@ -41,6 +41,12 @@ declare const debug: {
     diffenable: string | boolean;
     logFn: DebugLogger['logFn'];
     destroyAll: () => void;
+    onLogIntent: (channel: string, fn: (options: {
+        timestamp: number;
+        channel: string;
+        color: string;
+        args: any[];
+    }) => void) => VoidFunction;
 };
 
 interface LogFn {
@@ -69,16 +75,25 @@ type RenderRange = {
     renderEndIndex: number;
 };
 
-type Renderable = React$1.ReactNode | React$1.JSX.Element;
-
 type VoidFn$1 = () => void;
+
+type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
+interface SubscriptionCallback<T> {
+    (node: T, callback?: () => void): void;
+    get: () => T | null;
+    destroy: VoidFn$1;
+    onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn$1;
+    getListenersCount: () => number;
+}
+
+type VoidFn = () => void;
 type Pair<KeyType, ValueType> = {
     value?: ValueType;
     map?: Map<KeyType, Pair<KeyType, ValueType>>;
     length: number;
     revision?: number;
 };
-type DeepMapVisitFn<KeyType, ValueType, ReturnType = void> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn$1) => ReturnType;
+type DeepMapVisitFn<KeyType, ValueType, ReturnType = void> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn) => ReturnType;
 declare class DeepMap<KeyType, ValueType> {
     private map;
     private length;
@@ -105,8 +120,8 @@ declare class DeepMap<KeyType, ValueType> {
     has(keys: KeyType[]): boolean;
     private visitKey;
     visit: (fn: DeepMapVisitFn<KeyType, ValueType>) => void;
-    visitSome: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn$1) => boolean) => void;
-    visitDepthFirst: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn$1) => void) => void;
+    visitSome: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn) => boolean) => void;
+    visitDepthFirst: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn) => void) => void;
     private visitWithNext;
     private getArray;
     rawKeysAt(keys: KeyType[]): KeyType[];
@@ -120,7 +135,216 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
-type VoidFn = () => void;
+type NodePath$1<PRIMARY_KEY_TYPE = any> = PRIMARY_KEY_TYPE[];
+type TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE = any> = {
+    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    defaultExpanded: boolean;
+    collapsedIds?: never;
+    expandedIds?: never;
+} | {
+    defaultExpanded: true;
+    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    expandedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
+    collapsedIds?: never;
+    expandedIds?: never;
+} | {
+    defaultExpanded: false;
+    collapsedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
+    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    collapsedIds?: never;
+    expandedIds?: never;
+};
+type TreeExpandStateObject_ById<PRIMARY_KEY_TYPE = any> = {
+    defaultExpanded: boolean;
+    expandedIds: PRIMARY_KEY_TYPE[];
+    collapsedIds: PRIMARY_KEY_TYPE[];
+    expandedPaths?: never;
+    collapsedPaths?: never;
+} | {
+    defaultExpanded: true;
+    collapsedIds: PRIMARY_KEY_TYPE[];
+    expandedIds?: PRIMARY_KEY_TYPE[];
+    expandedPaths?: never;
+    collapsedPaths?: never;
+} | {
+    defaultExpanded: false;
+    collapsedIds?: PRIMARY_KEY_TYPE[];
+    expandedIds: PRIMARY_KEY_TYPE[];
+    expandedPaths?: never;
+    collapsedPaths?: never;
+};
+type TreeExpandStateObject<PRIMARY_KEY_TYPE = any> = TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE> | TreeExpandStateObject_ById<PRIMARY_KEY_TYPE>;
+type TreeExpandStateMode = 'id' | 'path';
+declare class TreeExpandState<PRIMARY_KEY_TYPE = any> {
+    collapsedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
+    expandedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
+    collapsedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
+    expandedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
+    private _mode;
+    get mode(): TreeExpandStateMode;
+    defaultExpanded: boolean;
+    constructor(clone?: TreeExpandStateObject | TreeExpandState);
+    reset(): void;
+    destroy(): void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    expandNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
+    collapseNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
+    setNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>, expanded: boolean): void;
+    isNodeExpandedByPath(nodePath: NodePath$1<PRIMARY_KEY_TYPE>): boolean;
+    isNodeExpandedById(id: PRIMARY_KEY_TYPE): boolean;
+    isNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): boolean;
+    update(stateObject: TreeExpandStateObject): void;
+    getState(): TreeExpandStateObject;
+}
+
+type DataSourceMutation<T> = {
+    type: 'delete';
+    primaryKey: any;
+    nodePath?: never;
+    originalData: T;
+    metadata: any;
+} | {
+    type: 'delete';
+    primaryKey?: never;
+    nodePath: NodePath$1;
+    originalData: T;
+    metadata: any;
+} | {
+    type: 'update';
+    primaryKey: any;
+    nodePath?: never;
+    data: Partial<T>;
+    originalData: T;
+    metadata: any;
+} | {
+    type: 'update';
+    primaryKey?: never;
+    nodePath: NodePath$1;
+    data: Partial<T>;
+    originalData: T;
+    metadata: any;
+} | {
+    type: 'update-children';
+    primaryKey?: never;
+    nodePath: NodePath$1;
+    children: UpdateChildrenFn<T>;
+    originalData: T;
+    metadata: any;
+} | {
+    type: 'insert';
+    primaryKey: any;
+    nodePath?: never;
+    position: 'before' | 'after';
+    originalData: null;
+    data: T;
+    metadata: any;
+} | {
+    type: 'insert';
+    primaryKey?: never;
+    nodePath: NodePath$1;
+    position: 'before' | 'after';
+    originalData: null;
+    data: T;
+    metadata: any;
+} | {
+    type: 'clear-all';
+    primaryKey: undefined;
+    metadata: any;
+};
+declare class DataSourceCache<DataType, PrimaryKeyType = string> {
+    private affectedFields;
+    private allFieldsAffected;
+    private nodesKey;
+    private primaryKeyToData;
+    private nodePathToData;
+    constructor(options: {
+        nodesKey: string | undefined;
+    });
+    static clone<DataType, PrimaryKeyType = string>(cache: DataSourceCache<DataType, PrimaryKeyType>, { light }?: {
+        light?: boolean;
+    }): DataSourceCache<DataType, PrimaryKeyType>;
+    getAffectedFields: () => true | Set<keyof DataType>;
+    delete: (primaryKey: PrimaryKeyType, originalData: DataType, metadata: any) => void;
+    deleteNodePath: (nodePath: NodePath$1<any>, originalData: DataType, metadata: any) => void;
+    insert: (primaryKey: PrimaryKeyType, data: DataType, position: 'before' | 'after', metadata: any) => void;
+    insertNodePath: (nodePath: NodePath$1<any>, data: DataType, position: 'before' | 'after', metadata: any) => void;
+    update: (primaryKey: PrimaryKeyType, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
+    updateNodePath: (nodePath: NodePath$1<any>, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
+    updateChildren: (nodePath: NodePath$1<any>, children: UpdateChildrenFn<DataType>, originalData: DataType, metadata: any) => void;
+    resetDataSource: (metadata: any) => void;
+    shouldResetDataSource: () => boolean;
+    clear: () => void;
+    isEmpty: () => boolean;
+    removeInfo: (primaryKey: PrimaryKeyType) => void;
+    removeNodePathInfo: (nodePath: NodePath$1<any>) => void;
+    getMutationsForPrimaryKey: (primaryKey: PrimaryKeyType) => DataSourceMutation<DataType>[] | undefined;
+    getMutationsForNodePath: (nodePath: NodePath$1<any>) => DataSourceMutation<DataType>[] | undefined;
+    getMutationsCount: () => number;
+    getMutations: () => Map<PrimaryKeyType, DataSourceMutation<DataType>[]>;
+    getTreeMutations: () => DeepMap<NodePath$1<any>, DataSourceMutation<DataType>[]>;
+    getMutationsArray: () => DataSourceMutation<DataType>[];
+    getTreeMutationsArray: () => DataSourceMutation<DataType>[];
+}
+
+type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT, COMPONENT_SETUP_STATE> = {
+    [propName in keyof TYPE_PROPS & keyof TYPE_RESULT]: 1 | ((value: TYPE_PROPS[propName], setupState: COMPONENT_SETUP_STATE) => TYPE_RESULT[propName]);
+};
+type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
+    debugName?: string | ((props: T_PROPS) => string);
+    initSetupState?: (props: T_PROPS) => COMPONENT_SETUP_STATE;
+    layoutEffect?: boolean;
+    forwardProps?: (setupState: COMPONENT_SETUP_STATE, props: T_PROPS) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE>;
+    allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
+    interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
+    mappedCallbacks?: ComponentMappedCallbacks<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
+    onPropChange?: (params: {
+        name: keyof T_PROPS;
+        oldValue: any;
+        newValue: any;
+    }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>, state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>) => void;
+    onPropsChange?: (newPropValues: {
+        [k in keyof T_PROPS]?: {
+            newValue: T_PROPS[k];
+            oldValue: T_PROPS[k];
+        };
+    }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>, state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>) => void;
+    mapPropsToState?: (params: {
+        props: T_PROPS;
+        state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>;
+        oldState: null | (COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>);
+        parentState: T_PARENT_STATE | null;
+    }) => COMPONENT_DERIVED_STATE;
+    concludeReducer?: (params: {
+        previousState: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
+        state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
+        updatedProps: Partial<T_PROPS> | null;
+        parentState: T_PARENT_STATE | null;
+    }) => COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
+    getReducerActions?: (dispatch: React$1.Dispatch<any>) => T_ACTIONS;
+    getParentState?: () => T_PARENT_STATE;
+    cleanup?: (state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE) => void;
+    onControlledPropertyChange?: (name: string, newValue: any, oldValue: any) => void | ((value: any, oldValue: any) => any);
+};
+declare function buildManagedComponent<T_PROPS extends object, COMPONENT_MAPPED_STATE extends object, COMPONENT_SETUP_STATE extends object = {}, COMPONENT_DERIVED_STATE extends object = {}, T_ACTIONS = {}, T_PARENT_STATE = {}>(config: ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE, COMPONENT_DERIVED_STATE, T_ACTIONS, T_PARENT_STATE>): {
+    ManagedComponentContextProvider: React$1.NamedExoticComponent<T_PROPS & {
+        children: React$1.ReactNode;
+    }>;
+    useManagedComponent: (props: T_PROPS) => {
+        contextValue: {
+            componentState: COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE;
+            componentActions: ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
+            getComponentState: () => COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE;
+            replaceState: (newState: COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE) => void;
+            assignState: (newState: Partial<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>) => void;
+        };
+        ContextComponent: React$1.Context<ManagedComponentStateContextValue<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE, ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>>>;
+    };
+};
+declare function useManagedComponentState<COMPONENT_STATE>(): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
+
+type Renderable = React$1.ReactNode | React$1.JSX.Element;
 
 type TableRenderRange = {
     start: [number, number];
@@ -432,378 +656,114 @@ declare class MatrixBrain extends Logger implements IBrain {
     private getCellSpan;
     getRowspan: (rowIndex: number, colIndex: number) => number;
     getColspan: (rowIndex: number, colIndex: number) => number;
-    getRowspanParent: (rowIndex: number, colIndex: number) => number;
-    getColspanParent: (rowIndex: number, colIndex: number) => number;
-    getItemSpanParent: (rowIndex: number, colIndex: number, direction: 'horizontal' | 'vertical') => number;
-    getRowHeightWithSpan: (rowIndex: number, colIndex: number, rowspan: number) => number;
-    getColWidthWithSpan: (rowIndex: number, colIndex: number, colspan: number) => number;
-    private getItemSizeWithSpan;
-    getRowHeight: (rowIndex: number) => number;
-    getColWidth: (colIndex: number) => number;
-    /**
-     * For now, this doesn't take into account the row/colspan, and it's okay not to
-     * @param itemIndex
-     * @returns the size of the specified item
-     */
-    getItemSize: (itemIndex: number, direction: 'horizontal' | 'vertical') => number;
-    getRowIndexInPage(rowIndex: number): number;
-    getPageIndexForRow(_rowIndex: number): number;
-    getVirtualizedContentSize(): {
-        height: number;
-        width: number;
-    };
-    getVirtualizedContentSizeFor(direction: 'horizontal' | 'vertical'): number;
-    keepColumnRendered: (colIndex: number) => () => void;
-    getAlwaysRenderedColumns: () => number[];
-    setRenderRange: ({ horizontal, vertical, extraCells, }: {
-        horizontal: RenderRangeType;
-        vertical: RenderRangeType;
-        extraCells?: [number, number][] | undefined;
-    }) => void;
-    getRenderRangeCellCount: (range: TableRenderRange) => number;
-    getMaxCellCount: () => number;
-    getExtraCells: () => [
-        number,
-        number
-    ][];
-    getScrollPosition: () => ScrollPosition;
-    getRenderRange: () => TableRenderRange;
-    onScroll: (fn: OnScrollFn) => () => void;
-    onScrollStart: (fn: VoidFunction) => () => void;
-    onScrollStop: (fn: (scrollPos: ScrollPosition) => void) => () => void;
-    onRenderRangeChange: (fn: FnOnRenderRangeChange) => () => void;
-    onVerticalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
-    onHorizontalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
-    onRenderCountChange: (fn: FnOnRenderCountChange) => () => void;
-    onAvailableSizeChange: (fn: OnAvailableSizeChange) => () => void;
-    onDestroy: (fn: VoidFn) => () => void;
-    getAvailableSize: () => {
-        width: number;
-        height: number;
-    };
-    protected getAvailableRenderSize: () => {
-        width: number;
-        height: number;
-    };
-    private notifyDestroy;
-    destroy(): void;
-}
-
-type CellSelectionPosition<ROW_PRIMARY_KEY_TYPE = any, COL_ID = string> = [ROW_PRIMARY_KEY_TYPE, COL_ID];
-type CellSelectionStateObject = {
-    selectedCells: CellSelectionPosition[];
-    deselectedCells: CellSelectionPosition[];
-    defaultSelection: boolean;
-} | {
-    defaultSelection: true;
-    deselectedCells: CellSelectionPosition[];
-    selectedCells?: CellSelectionPosition[];
-} | {
-    defaultSelection: false;
-    selectedCells: CellSelectionPosition[];
-    deselectedCells?: CellSelectionPosition[];
-};
-declare class CellSelectionState {
-    wildcard: string;
-    cache: DeepMap<any, boolean>;
-    selectedRowsToColumns: Map<any, Set<string>>;
-    selectedColumnsToRows: Map<string, Set<any>>;
-    deselectedRowsToColumns: Map<any, Set<string>>;
-    deselectedColumnsToRows: Map<string, Set<any>>;
-    defaultSelection: boolean;
-    constructor(clone?: CellSelectionStateObject | CellSelectionState);
-    deselectAll: () => void;
-    selectAll: () => void;
-    selectCell(rowId: any, colId: string): void;
-    deselectCell(rowId: any, colId: string): void;
-    selectColumn(colId: string): void;
-    deselectColumn(colId: string): void;
-    setCellSelected(rowId: any, colId: string, selected: boolean): void;
-    private setCellInDeselection;
-    private setCellInSelection;
-    update(stateObject: CellSelectionStateObject): void;
-    /**
-     * Returns whether there is at least one selected cell in the row
-     *
-     * @param rowId the row id
-     * @param columnIds the columns currently available in the grid
-     * @returns boolean
-     */
-    isCellSelectionInRow(rowId: any, columnIds: string[]): boolean;
-    isCellSelected(rowId: any, colId: string): boolean;
-    private isCellSelected_Internal;
-    getState(): CellSelectionStateObject;
-}
-
-type PointCoords = {
-    top: number;
-    left: number;
-};
-
-type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT, COMPONENT_SETUP_STATE> = {
-    [propName in keyof TYPE_PROPS & keyof TYPE_RESULT]: 1 | ((value: TYPE_PROPS[propName], setupState: COMPONENT_SETUP_STATE) => TYPE_RESULT[propName]);
-};
-type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
-    debugName?: string;
-    initSetupState?: (props: T_PROPS) => COMPONENT_SETUP_STATE;
-    layoutEffect?: boolean;
-    forwardProps?: (setupState: COMPONENT_SETUP_STATE, props: T_PROPS) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE>;
-    allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
-    interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
-    mappedCallbacks?: ComponentMappedCallbacks<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
-    onPropChange?: (params: {
-        name: keyof T_PROPS;
-        oldValue: any;
-        newValue: any;
-    }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>, state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>) => void;
-    onPropsChange?: (newPropValues: {
-        [k in keyof T_PROPS]?: {
-            newValue: T_PROPS[k];
-            oldValue: T_PROPS[k];
-        };
-    }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>, state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>) => void;
-    mapPropsToState?: (params: {
-        props: T_PROPS;
-        state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>;
-        oldState: null | (COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>);
-        parentState: T_PARENT_STATE | null;
-    }) => COMPONENT_DERIVED_STATE;
-    concludeReducer?: (params: {
-        previousState: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
-        state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
-        updatedProps: Partial<T_PROPS> | null;
-        parentState: T_PARENT_STATE | null;
-    }) => COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
-    getReducerActions?: (dispatch: React$1.Dispatch<any>) => T_ACTIONS;
-    getParentState?: () => T_PARENT_STATE;
-    cleanup?: (state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE) => void;
-    onControlledPropertyChange?: (name: string, newValue: any, oldValue: any) => void | ((value: any, oldValue: any) => any);
-};
-declare function buildManagedComponent<T_PROPS extends object, COMPONENT_MAPPED_STATE extends object, COMPONENT_SETUP_STATE extends object = {}, COMPONENT_DERIVED_STATE extends object = {}, T_ACTIONS = {}, T_PARENT_STATE = {}>(config: ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE, COMPONENT_DERIVED_STATE, T_ACTIONS, T_PARENT_STATE>): {
-    ManagedComponentContextProvider: React$1.NamedExoticComponent<T_PROPS & {
-        children: React$1.ReactNode;
-    }>;
-    useManagedComponent: (props: T_PROPS) => {
-        contextValue: {
-            componentState: COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE;
-            componentActions: ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
-            getComponentState: () => COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE;
-            replaceState: (newState: COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE) => void;
-            assignState: (newState: Partial<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>) => void;
-        };
-        ContextComponent: React$1.Context<ManagedComponentStateContextValue<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE, ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>>>;
-    };
-};
-declare function useManagedComponentState<COMPONENT_STATE>(): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
-
-type NodePath$1<PRIMARY_KEY_TYPE = any> = PRIMARY_KEY_TYPE[];
-type TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE = any> = {
-    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
-    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
-    defaultExpanded: boolean;
-    collapsedIds?: never;
-    expandedIds?: never;
-} | {
-    defaultExpanded: true;
-    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
-    expandedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
-    collapsedIds?: never;
-    expandedIds?: never;
-} | {
-    defaultExpanded: false;
-    collapsedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
-    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
-    collapsedIds?: never;
-    expandedIds?: never;
-};
-type TreeExpandStateObject_ById<PRIMARY_KEY_TYPE = any> = {
-    defaultExpanded: boolean;
-    expandedIds: PRIMARY_KEY_TYPE[];
-    collapsedIds: PRIMARY_KEY_TYPE[];
-    expandedPaths?: never;
-    collapsedPaths?: never;
-} | {
-    defaultExpanded: true;
-    collapsedIds: PRIMARY_KEY_TYPE[];
-    expandedIds?: PRIMARY_KEY_TYPE[];
-    expandedPaths?: never;
-    collapsedPaths?: never;
-} | {
-    defaultExpanded: false;
-    collapsedIds?: PRIMARY_KEY_TYPE[];
-    expandedIds: PRIMARY_KEY_TYPE[];
-    expandedPaths?: never;
-    collapsedPaths?: never;
-};
-type TreeExpandStateObject<PRIMARY_KEY_TYPE = any> = TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE> | TreeExpandStateObject_ById<PRIMARY_KEY_TYPE>;
-type TreeExpandStateMode = 'id' | 'path';
-declare class TreeExpandState<PRIMARY_KEY_TYPE = any> {
-    collapsedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
-    expandedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
-    collapsedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
-    expandedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
-    private _mode;
-    get mode(): TreeExpandStateMode;
-    defaultExpanded: boolean;
-    constructor(clone?: TreeExpandStateObject | TreeExpandState);
-    reset(): void;
-    destroy(): void;
-    expandAll: () => void;
-    collapseAll: () => void;
-    expandNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
-    collapseNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
-    setNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>, expanded: boolean): void;
-    isNodeExpandedByPath(nodePath: NodePath$1<PRIMARY_KEY_TYPE>): boolean;
-    isNodeExpandedById(id: PRIMARY_KEY_TYPE): boolean;
-    isNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): boolean;
-    update(stateObject: TreeExpandStateObject): void;
-    getState(): TreeExpandStateObject;
-}
-
-type NonUndefined<T> = T extends undefined ? never : T;
-
-type OnNodeStateChangeParam = DataSourceCallback_BaseParam<any> & {};
-type TreeDataSourceOnlyProps<T> = {
-    nodesKey?: string;
-    treeSelection?: DataSourcePropTreeSelection;
-    treeFilterFunction?: DataSourcePropTreeFilterFunction<T>;
-    defaultTreeSelection?: DataSourcePropTreeSelection;
-    treeExpandState?: TreeExpandStateValue;
-    defaultTreeExpandState?: TreeExpandStateValue;
-    onTreeExpandStateChange?: (treeExpandState: TreeExpandStateObject<any>, params: {
-        dataSourceApi: DataSourceApi<T>;
-        nodePath: NodePath$1 | null;
-        nodeState: 'collapsed' | 'expanded';
-    }) => void;
-    onTreeDataMutations?: ({ dataArray, timestamp, treeMutations, nodesKey, }: {
-        nodesKey: keyof T | any;
-        dataArray: DataSourceState<T>['originalDataArray'];
-        timestamp: number;
-        treeMutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['treeMutations']>;
-    }) => void;
-    isNodeSelected?: DataSourcePropIsNodeSelected<T>;
-    isNodeSelectable?: DataSourcePropIsNodeSelectable<T>;
-    isNodeReadOnly?: DataSourcePropIsNodeReadOnly<T>;
-    /**
-     * Called when a node is expanded. Not called when treeApi.expandAll is called.
-     */
-    onNodeExpand?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
-    /**
-     * Called when a node is collapsed. Not called when treeApi.collapseAll is called.
-     */
-    onNodeCollapse?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
-} & ({
-    selectionMode?: 'multi-row';
-    treeSelection?: DataSourcePropTreeSelection_MultiNode;
-    defaultTreeSelection?: DataSourcePropTreeSelection_MultiNode;
-    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_MultiNode;
-} | {
-    selectionMode?: 'single-row';
-    treeSelection?: DataSourcePropTreeSelection_SingleNode;
-    defaultTreeSelection?: DataSourcePropTreeSelection_SingleNode;
-    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_SingleNode;
-} | {
-    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;
-}) & ({
-    isNodeCollapsed?: DataSourcePropIsNodeExpanded<T>;
-    isNodeExpanded?: never;
-} | {
-    isNodeExpanded?: DataSourcePropIsNodeExpanded<T>;
-    isNodeCollapsed?: never;
-});
-type DataSourcePropsNotAvailableInTreeDataSource = keyof Pick<DataSourceProps<any>, 'groupBy' | 'defaultGroupBy' | 'nodesKey' | 'defaultGroupRowsState' | 'groupRowsState' | 'onGroupRowsStateChange' | 'onGroupByChange' | 'collapseGroupRowsOnDataFunctionChange' | 'livePagination' | 'onLivePaginationCursorChange' | 'groupMode' | 'filterFunction' | 'onPivotByChange' | 'pivotBy' | 'defaultPivotBy' | 'selectionMode' | 'rowSelection' | 'defaultRowSelection'>;
-type TreeDataSourceProps<T> = Omit<DataSourceProps<T>, DataSourcePropsNotAvailableInTreeDataSource> & TreeDataSourceOnlyProps<T>;
+    getRowspanParent: (rowIndex: number, colIndex: number) => number;
+    getColspanParent: (rowIndex: number, colIndex: number) => number;
+    getItemSpanParent: (rowIndex: number, colIndex: number, direction: 'horizontal' | 'vertical') => number;
+    getRowHeightWithSpan: (rowIndex: number, colIndex: number, rowspan: number) => number;
+    getColWidthWithSpan: (rowIndex: number, colIndex: number, colspan: number) => number;
+    private getItemSizeWithSpan;
+    getRowHeight: (rowIndex: number) => number;
+    getColWidth: (colIndex: number) => number;
+    /**
+     * For now, this doesn't take into account the row/colspan, and it's okay not to
+     * @param itemIndex
+     * @returns the size of the specified item
+     */
+    getItemSize: (itemIndex: number, direction: 'horizontal' | 'vertical') => number;
+    getRowIndexInPage(rowIndex: number): number;
+    getPageIndexForRow(_rowIndex: number): number;
+    getVirtualizedContentSize(): {
+        height: number;
+        width: number;
+    };
+    getVirtualizedContentSizeFor(direction: 'horizontal' | 'vertical'): number;
+    keepColumnRendered: (colIndex: number) => () => void;
+    getAlwaysRenderedColumns: () => number[];
+    setRenderRange: ({ horizontal, vertical, extraCells, }: {
+        horizontal: RenderRangeType;
+        vertical: RenderRangeType;
+        extraCells?: [number, number][] | undefined;
+    }) => void;
+    getRenderRangeCellCount: (range: TableRenderRange) => number;
+    getMaxCellCount: () => number;
+    getExtraCells: () => [
+        number,
+        number
+    ][];
+    getScrollPosition: () => ScrollPosition;
+    getRenderRange: () => TableRenderRange;
+    onScroll: (fn: OnScrollFn) => () => void;
+    onScrollStart: (fn: VoidFunction) => () => void;
+    onScrollStop: (fn: (scrollPos: ScrollPosition) => void) => () => void;
+    onRenderRangeChange: (fn: FnOnRenderRangeChange) => () => void;
+    onVerticalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
+    onHorizontalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
+    onRenderCountChange: (fn: FnOnRenderCountChange) => () => void;
+    onAvailableSizeChange: (fn: OnAvailableSizeChange) => () => void;
+    onDestroy: (fn: VoidFn$1) => () => void;
+    getAvailableSize: () => {
+        width: number;
+        height: number;
+    };
+    protected getAvailableRenderSize: () => {
+        width: number;
+        height: number;
+    };
+    private notifyDestroy;
+    destroy(): void;
+}
 
-type NodePath = any[];
-type TreeSelectionStateObject = {
-    selectedPaths: NodePath;
-    deselectedPaths: NodePath;
+type CellSelectionPosition<ROW_PRIMARY_KEY_TYPE = any, COL_ID = string> = [ROW_PRIMARY_KEY_TYPE, COL_ID];
+type CellSelectionStateObject = {
+    selectedCells: CellSelectionPosition[];
+    deselectedCells: CellSelectionPosition[];
     defaultSelection: boolean;
 } | {
     defaultSelection: true;
-    deselectedPaths: NodePath;
-    selectedPaths?: NodePath;
+    deselectedCells: CellSelectionPosition[];
+    selectedCells?: CellSelectionPosition[];
 } | {
     defaultSelection: false;
-    selectedPaths: NodePath;
-    deselectedPaths?: NodePath;
-};
-type TreeSelectionStateConfig<_T = any> = {
-    treeDeepMap: DeepMap<any, DeepMapTreeValueType<any, any>>;
-};
-type GetTreeSelectionStateConfig<T> = () => TreeSelectionStateConfig<T>;
-type NodeSelectionState = {
-    selected: boolean | null;
-    selectedCount: number;
-    deselectedCount: number;
-    leafCount: number;
+    selectedCells: CellSelectionPosition[];
+    deselectedCells?: CellSelectionPosition[];
 };
-declare class TreeSelectionState<T = any> {
-    selectedPaths: NodePath[] | null;
-    deselectedPaths: NodePath[] | null;
+declare class CellSelectionState {
+    wildcard: string;
+    cache: DeepMap<any, boolean>;
+    selectedRowsToColumns: Map<any, Set<string>>;
+    selectedColumnsToRows: Map<string, Set<any>>;
+    deselectedRowsToColumns: Map<any, Set<string>>;
+    deselectedColumnsToRows: Map<string, Set<any>>;
     defaultSelection: boolean;
-    selectionMap: DeepMap<NodePath, boolean>;
-    cache: DeepMap<NodePath, NodeSelectionState>;
-    getConfig: GetTreeSelectionStateConfig<T>;
-    getTreeDeepMap(): DeepMap<any, DeepMapTreeValueType<any, any>>;
-    isLeafNode(nodePath: NodePath): boolean;
-    getLeafNodesCount(nodePath: NodePath): number;
-    static from<T>(treeSelectionState: TreeSelectionStateObject, getConfig: GetTreeSelectionStateConfig<T>): TreeSelectionState<T>;
-    constructor(state: TreeSelectionStateObject | TreeSelectionState, getConfig: GetTreeSelectionStateConfig<T>);
-    setConfigFn(getConfig: GetTreeSelectionStateConfig<T>): void;
-    xcache(): void;
-    update(stateObject: TreeSelectionStateObject): void;
-    setSelectionForPath(nodePath: NodePath, selected: boolean): void;
-    getState(): TreeSelectionStateObject;
-    deselectAll(): void;
-    selectAll(): void;
-    isNodeSelected(nodePath: NodePath): boolean | null;
-    private isSelfSelected;
-    private cacheIt;
-    private getSelectionStateForNode;
-    private isPathSelected;
-    private getNodeBooleanSelectionStateFromParent;
-    setNodeSelection(nodePath: NodePath, selected: boolean): void;
-    selectNode(nodePath: NodePath): void;
-    deselectNode(nodePath: any[]): void;
-    toggleNodeSelection(nodePath: NodePath): void;
-    getSelectedCount(): number;
-    getDeselectedCount(): number;
-    getSelectionCountFor(nodePath?: NodePath): {
-        selectedCount: number;
-        deselectedCount: number;
-    };
-    destroy(): void;
+    debugId: string;
+    constructor(clone?: CellSelectionStateObject | CellSelectionState);
+    deselectAll: () => void;
+    selectAll: () => void;
+    selectCell(rowId: any, colId: string): void;
+    deselectCell(rowId: any, colId: string): void;
+    selectColumn(colId: string): void;
+    deselectColumn(colId: string): void;
+    setCellSelected(rowId: any, colId: string, selected: boolean): void;
+    private setCellInDeselection;
+    private setCellInSelection;
+    update(stateObject: CellSelectionStateObject): void;
+    /**
+     * Returns whether there is at least one selected cell in the row
+     *
+     * @param rowId the row id
+     * @param columnIds the columns currently available in the grid
+     * @returns boolean
+     */
+    isCellSelectionInRow(rowId: any, columnIds: string[]): boolean;
+    private error;
+    isCellSelected(rowId: any, colId: string): boolean;
+    private isCellSelected_Internal;
+    getState(): CellSelectionStateObject;
 }
 
-type DataSourceStateRestoreForDetail<T> = {
-    originalDataArray: DataSourceState<T>['originalDataArray'] | undefined;
-    groupBy: DataSourceState<T>['groupBy'] | undefined;
-    groupRowsState: DataSourceState<T>['groupRowsState'] | undefined;
-    pivotBy: DataSourceState<T>['pivotBy'] | undefined;
-    sortInfo: DataSourceState<T>['sortInfo'] | undefined;
-    filterValue: DataSourceState<T>['filterValue'] | undefined;
-    livePaginationCursor: DataSourceState<T>['livePaginationCursor'] | undefined;
-};
-type RowDetailCacheKey = string | number;
-type RowDetailCacheEntry = {
-    all?: boolean;
-    groupBy?: boolean;
-    sortInfo?: boolean;
-    filterValue?: boolean;
-    data?: boolean;
-    livePaginationCursor?: boolean;
-    columnOrder?: boolean;
+type PointCoords = {
+    top: number;
+    left: number;
 };
 
 interface RowDetailCacheStorage<_K, T> {
@@ -979,7 +939,7 @@ declare class GridCellManager<T_ADDITIONAL_CELL_INFO> extends Logger {
     detachColsStartingWith(colIndex: number): void;
     detachCellsStartingAt(cellPos: CellPos): void;
     detachCellAt(cellPos: CellPos): boolean;
-    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFn;
+    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFn$1;
     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;
@@ -1038,7 +998,7 @@ declare class ListRowManager extends Logger {
     detachRow(row: ListRowInterface): void;
     renderNodeAtRow(node: Renderable, row: ListRowInterface, rowIndex: number): ListRowInterface;
     makeDetachedRowsEmpty(): void;
-    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFn;
+    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFn$1;
     withDetachedRows(fn: (row: ListRowInterface) => void): void;
     destroy(): void;
     reset(): void;
@@ -1158,13 +1118,7 @@ type MultiSelectRangeOptions = {
     columnsPerSet: number;
 };
 
-type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
-interface SubscriptionCallback<T> {
-    (node: T, callback?: () => void): void;
-    get: () => T | null;
-    destroy: VoidFn;
-    onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
-}
+type NonUndefined<T> = T extends undefined ? never : T;
 
 declare class ScrollListener {
     private scrollPosition;
@@ -1587,6 +1541,102 @@ type InfiniteTableComputedColumnBase<T> = {
 type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
 type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 
+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;
+
 type CellContextMenuLocation = {
     rowId: any;
     rowIndex: number;
@@ -1606,6 +1656,8 @@ interface InfiniteTableSetupState<T> {
     headerBrain: MatrixBrain;
     renderer: GridRenderer;
     onRenderUpdater: SubscriptionCallback<Renderable>;
+    debugWarnings: Map<InfiniteTableDebugWarningKey, DebugWarningPayload>;
+    devToolsDetected: boolean;
     forceBodyRerenderTimestamp: number;
     lastRowToExpandRef: MutableRefObject<any | null>;
     lastRowToCollapseRef: MutableRefObject<any | null>;
@@ -1687,7 +1739,6 @@ type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTota
 interface InfiniteTableMappedState<T> {
     id: InfiniteTableProps<T>['id'];
     debugId: InfiniteTableProps<T>['debugId'];
-    debugMode: NonUndefined<InfiniteTableProps<T>['debugMode']>;
     scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
     multiSortBehavior: NonUndefined<InfiniteTableProps<T>['multiSortBehavior']>;
     viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
@@ -1696,6 +1747,8 @@ interface InfiniteTableMappedState<T> {
     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>;
@@ -2096,33 +2149,95 @@ interface InfiniteTableComputedValues<T> {
         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;
+    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 NodePath = any[];
+type TreeSelectionStateObject = {
+    selectedPaths: NodePath;
+    deselectedPaths: NodePath;
+    defaultSelection: boolean;
+} | {
+    defaultSelection: true;
+    deselectedPaths: NodePath;
+    selectedPaths?: NodePath;
+} | {
+    defaultSelection: false;
+    selectedPaths: NodePath;
+    deselectedPaths?: NodePath;
+};
+type TreeSelectionStateConfig<_T = any> = {
+    treeDeepMap: DeepMap<any, DeepMapTreeValueType<any, any>>;
+};
+type GetTreeSelectionStateConfig<T> = () => TreeSelectionStateConfig<T>;
+type NodeSelectionState = {
+    selected: boolean | null;
+    selectedCount: number;
+    deselectedCount: number;
+    leafCount: number;
+};
+declare class TreeSelectionState<T = any> {
+    selectedPaths: NodePath[] | null;
+    deselectedPaths: NodePath[] | null;
+    defaultSelection: boolean;
+    selectionMap: DeepMap<NodePath, boolean>;
+    cache: DeepMap<NodePath, NodeSelectionState>;
+    getConfig: GetTreeSelectionStateConfig<T>;
+    getTreeDeepMap(): DeepMap<any, DeepMapTreeValueType<any, any>>;
+    isLeafNode(nodePath: NodePath): boolean;
+    getLeafNodesCount(nodePath: NodePath): number;
+    static from<T>(treeSelectionState: TreeSelectionStateObject, getConfig: GetTreeSelectionStateConfig<T>): TreeSelectionState<T>;
+    constructor(state: TreeSelectionStateObject | TreeSelectionState, getConfig: GetTreeSelectionStateConfig<T>);
+    setConfigFn(getConfig: GetTreeSelectionStateConfig<T>): void;
+    xcache(): void;
+    update(stateObject: TreeSelectionStateObject): void;
+    setSelectionForPath(nodePath: NodePath, selected: boolean): void;
+    getState(): TreeSelectionStateObject;
+    deselectAll(): void;
+    selectAll(): void;
+    isNodeSelected(nodePath: NodePath): boolean | null;
+    private isSelfSelected;
+    private cacheIt;
+    private getSelectionStateForNode;
+    private isPathSelected;
+    private getNodeBooleanSelectionStateFromParent;
+    setNodeSelection(nodePath: NodePath, selected: boolean): void;
+    selectNode(nodePath: NodePath): void;
+    deselectNode(nodePath: any[]): void;
+    toggleNodeSelection(nodePath: NodePath): void;
+    getSelectedCount(): number;
+    getDeselectedCount(): number;
+    getSelectionCountFor(nodePath?: NodePath): {
+        selectedCount: number;
+        deselectedCount: number;
+    };
+    destroy(): void;
 }
 
 type InfiniteTableEventHandlerContext<T> = {
@@ -2166,6 +2281,9 @@ interface InfiniteTablePublicContext<T> {
     getState: () => InfiniteTableState<T>;
     getDataSourceState: () => DataSourceState<T>;
 }
+type InfiniteTableRowContext<T> = InfiniteTablePublicContext<T> & InfiniteTableRowInfoDataDiscriminator<T> & {
+    rowIndex: number;
+};
 interface InfiniteTableCellContext<T> {
     rowIndex: OnCellClickContext<T>['rowIndex'];
     colIndex: OnCellClickContext<T>['colIndex'];
@@ -2240,94 +2358,67 @@ type NestedMultiSortOptions<T> = {
 };
 declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];
 
-type DataSourceMutation<T> = {
-    type: 'delete';
-    primaryKey: any;
-    nodePath?: never;
-    originalData: T;
-    metadata: any;
-} | {
-    type: 'delete';
-    primaryKey?: never;
-    nodePath: NodePath$1;
-    originalData: T;
-    metadata: any;
-} | {
-    type: 'update';
-    primaryKey: any;
-    nodePath?: never;
-    data: Partial<T>;
-    originalData: T;
-    metadata: any;
+type OnNodeStateChangeParam = DataSourceCallback_BaseParam<any> & {};
+type TreeDataSourceOnlyProps<T> = {
+    nodesKey?: string;
+    treeSelection?: DataSourcePropTreeSelection;
+    treeFilterFunction?: DataSourcePropTreeFilterFunction<T>;
+    defaultTreeSelection?: DataSourcePropTreeSelection;
+    treeExpandState?: TreeExpandStateValue;
+    defaultTreeExpandState?: TreeExpandStateValue;
+    onTreeExpandStateChange?: (treeExpandState: TreeExpandStateObject<any>, params: {
+        dataSourceApi: DataSourceApi<T>;
+        nodePath: NodePath$1 | null;
+        nodeState: 'collapsed' | 'expanded';
+    }) => void;
+    onTreeDataMutations?: ({ dataArray, timestamp, treeMutations, nodesKey, }: {
+        nodesKey: keyof T | any;
+        dataArray: DataSourceState<T>['originalDataArray'];
+        timestamp: number;
+        treeMutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['treeMutations']>;
+    }) => void;
+    isNodeSelected?: DataSourcePropIsNodeSelected<T>;
+    isNodeSelectable?: DataSourcePropIsNodeSelectable<T>;
+    isNodeReadOnly?: DataSourcePropIsNodeReadOnly<T>;
+    /**
+     * Called when a node is expanded. Not called when treeApi.expandAll is called.
+     */
+    onNodeExpand?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
+    /**
+     * Called when a node is collapsed. Not called when treeApi.collapseAll is called.
+     */
+    onNodeCollapse?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
+} & ({
+    selectionMode?: 'multi-row';
+    treeSelection?: DataSourcePropTreeSelection_MultiNode;
+    defaultTreeSelection?: DataSourcePropTreeSelection_MultiNode;
+    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_MultiNode;
 } | {
-    type: 'update';
-    primaryKey?: never;
-    nodePath: NodePath$1;
-    data: Partial<T>;
-    originalData: T;
-    metadata: any;
+    selectionMode?: 'single-row';
+    treeSelection?: DataSourcePropTreeSelection_SingleNode;
+    defaultTreeSelection?: DataSourcePropTreeSelection_SingleNode;
+    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_SingleNode;
 } | {
-    type: 'update-children';
-    primaryKey?: never;
-    nodePath: NodePath$1;
-    children: UpdateChildrenFn<T>;
-    originalData: T;
-    metadata: any;
+    selectionMode?: 'single-cell';
+    cellSelection?: DataSourcePropCellSelection_SingleCell;
+    defaultCellSelection?: DataSourcePropCellSelection_SingleCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_SingleCell;
 } | {
-    type: 'insert';
-    primaryKey: any;
-    nodePath?: never;
-    position: 'before' | 'after';
-    originalData: null;
-    data: T;
-    metadata: any;
+    selectionMode?: 'multi-cell';
+    cellSelection?: DataSourcePropCellSelection_MultiCell;
+    defaultCellSelection?: DataSourcePropCellSelection_MultiCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_MultiCell;
 } | {
-    type: 'insert';
-    primaryKey?: never;
-    nodePath: NodePath$1;
-    position: 'before' | 'after';
-    originalData: null;
-    data: T;
-    metadata: any;
+    selectionMode?: false;
+}) & ({
+    isNodeCollapsed?: DataSourcePropIsNodeExpanded<T>;
+    isNodeExpanded?: never;
 } | {
-    type: 'clear-all';
-    primaryKey: undefined;
-    metadata: any;
-};
-declare class DataSourceCache<DataType, PrimaryKeyType = string> {
-    private affectedFields;
-    private allFieldsAffected;
-    private nodesKey;
-    private primaryKeyToData;
-    private nodePathToData;
-    constructor(options: {
-        nodesKey: string | undefined;
-    });
-    static clone<DataType, PrimaryKeyType = string>(cache: DataSourceCache<DataType, PrimaryKeyType>, { light }?: {
-        light?: boolean;
-    }): DataSourceCache<DataType, PrimaryKeyType>;
-    getAffectedFields: () => true | Set<keyof DataType>;
-    delete: (primaryKey: PrimaryKeyType, originalData: DataType, metadata: any) => void;
-    deleteNodePath: (nodePath: NodePath$1<any>, originalData: DataType, metadata: any) => void;
-    insert: (primaryKey: PrimaryKeyType, data: DataType, position: 'before' | 'after', metadata: any) => void;
-    insertNodePath: (nodePath: NodePath$1<any>, data: DataType, position: 'before' | 'after', metadata: any) => void;
-    update: (primaryKey: PrimaryKeyType, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
-    updateNodePath: (nodePath: NodePath$1<any>, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
-    updateChildren: (nodePath: NodePath$1<any>, children: UpdateChildrenFn<DataType>, originalData: DataType, metadata: any) => void;
-    resetDataSource: (metadata: any) => void;
-    shouldResetDataSource: () => boolean;
-    clear: () => void;
-    isEmpty: () => boolean;
-    removeInfo: (primaryKey: PrimaryKeyType) => void;
-    removeNodePathInfo: (nodePath: NodePath$1<any>) => void;
-    getMutationsForPrimaryKey: (primaryKey: PrimaryKeyType) => DataSourceMutation<DataType>[] | undefined;
-    getMutationsForNodePath: (nodePath: NodePath$1<any>) => DataSourceMutation<DataType>[] | undefined;
-    getMutationsCount: () => number;
-    getMutations: () => Map<PrimaryKeyType, DataSourceMutation<DataType>[]>;
-    getTreeMutations: () => DeepMap<NodePath$1<any>, DataSourceMutation<DataType>[]>;
-    getMutationsArray: () => DataSourceMutation<DataType>[];
-    getTreeMutationsArray: () => DataSourceMutation<DataType>[];
-}
+    isNodeExpanded?: DataSourcePropIsNodeExpanded<T>;
+    isNodeCollapsed?: never;
+});
+type DataSourcePropsNotAvailableInTreeDataSource = keyof Pick<DataSourceProps<any>, 'groupBy' | 'defaultGroupBy' | 'nodesKey' | 'defaultGroupRowsState' | 'groupRowsState' | 'onGroupRowsStateChange' | 'onGroupByChange' | 'collapseGroupRowsOnDataFunctionChange' | 'livePagination' | 'onLivePaginationCursorChange' | 'groupMode' | 'filterFunction' | 'onPivotByChange' | 'pivotBy' | 'defaultPivotBy' | 'selectionMode' | 'rowSelection' | 'defaultRowSelection'>;
+type TreeDataSourceProps<T> = Omit<DataSourceProps<T>, DataSourcePropsNotAvailableInTreeDataSource> & TreeDataSourceOnlyProps<T>;
 
 type ForceOptions = {
     force?: boolean;
@@ -2506,8 +2597,6 @@ interface DataSourceMappedState<T> {
     onNodeCollapse: TreeDataSourceProps<T>['onNodeCollapse'];
     onNodeExpand: TreeDataSourceProps<T>['onNodeExpand'];
     isRowDisabled: DataSourceProps<T>['isRowDisabled'];
-    debugId: DataSourceProps<T>['debugId'];
-    debugMode: DataSourceProps<T>['debugMode'];
     nodesKey: NonUndefined<TreeDataSourceProps<T>['nodesKey']>;
     treeSelection: TreeDataSourceProps<T>['treeSelection'];
     batchOperationDelay: DataSourceProps<T>['batchOperationDelay'];
@@ -2579,7 +2668,13 @@ type LazyRowInfoGroup<DataType> = {
     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>;
@@ -2772,6 +2867,7 @@ interface DataSourceApi<T> {
     disableAllRows: () => void;
     areAllRowsEnabled: () => boolean;
     areAllRowsDisabled: () => boolean;
+    setGroupBy: (groupBy: DataSourceState<T>['groupBy']) => void;
 }
 type DataSourcePropRowInfoReducers<T> = Record<string, DataSourceRowInfoReducer<T>>;
 type DataSourceRowInfoReducer<T> = DataSourceRawReducer<InfiniteTableRowInfo<T>, any>;
@@ -2783,7 +2879,6 @@ type TreeExpandStateValue = TreeExpandState | TreeExpandStateObject<any>;
 type DataSourceProps<T> = {
     nodesKey?: never;
     debugId?: string;
-    debugMode?: InfiniteTablePropDebugMode;
     children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
     primaryKey: keyof T | ((data: T) => string);
     /**
@@ -2959,6 +3054,7 @@ 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>>>;
@@ -3102,6 +3198,26 @@ type InfiniteTableComponent = {
 };
 declare const InfiniteTable: InfiniteTableComponent;
 
+type DataSourceStateRestoreForDetail<T> = {
+    originalDataArray: DataSourceState<T>['originalDataArray'] | undefined;
+    groupBy: DataSourceState<T>['groupBy'] | undefined;
+    groupRowsState: DataSourceState<T>['groupRowsState'] | undefined;
+    pivotBy: DataSourceState<T>['pivotBy'] | undefined;
+    sortInfo: DataSourceState<T>['sortInfo'] | undefined;
+    filterValue: DataSourceState<T>['filterValue'] | undefined;
+    livePaginationCursor: DataSourceState<T>['livePaginationCursor'] | undefined;
+};
+type RowDetailCacheKey = string | number;
+type RowDetailCacheEntry = {
+    all?: boolean;
+    groupBy?: boolean;
+    sortInfo?: boolean;
+    filterValue?: boolean;
+    data?: boolean;
+    livePaginationCursor?: boolean;
+    columnOrder?: boolean;
+};
+
 declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
 
 declare function useDataSourceState<T>(): DataSourceState<T>;
@@ -3109,6 +3225,11 @@ declare function useDataSourceState<T>(): DataSourceState<T>;
 declare const useManagedDataSource: (props: object) => {
     contextValue: {
         componentState: {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3144,7 +3265,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3182,6 +3303,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -3213,8 +3335,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -3242,6 +3362,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3277,7 +3402,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3315,6 +3440,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -3346,8 +3472,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -3375,6 +3499,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3410,7 +3539,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3448,6 +3577,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -3479,8 +3609,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -3509,6 +3637,11 @@ declare const useManagedDataSource: (props: object) => {
             rowDisabledState: never;
         };
         componentActions: ComponentStateGeneratedActions<{
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3544,7 +3677,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3582,6 +3715,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -3613,8 +3747,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -3642,6 +3774,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3677,7 +3814,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3715,6 +3852,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -3746,8 +3884,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -3775,6 +3911,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3810,7 +3951,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3848,6 +3989,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -3879,8 +4021,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -3909,6 +4049,11 @@ declare const useManagedDataSource: (props: object) => {
             rowDisabledState: never;
         }>;
         getComponentState: () => {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -3944,7 +4089,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3982,6 +4127,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4013,8 +4159,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4042,6 +4186,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4077,7 +4226,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4115,6 +4264,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4146,8 +4296,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4175,6 +4323,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4210,7 +4363,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4248,6 +4401,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4279,8 +4433,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4309,6 +4461,11 @@ declare const useManagedDataSource: (props: object) => {
             rowDisabledState: never;
         };
         replaceState: (newState: {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4344,7 +4501,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4382,6 +4539,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4413,8 +4571,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4442,6 +4598,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4477,7 +4638,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4515,6 +4676,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4546,8 +4708,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4575,6 +4735,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4610,7 +4775,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4648,6 +4813,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4679,8 +4845,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4709,6 +4873,11 @@ declare const useManagedDataSource: (props: object) => {
             rowDisabledState: never;
         }) => void;
         assignState: (newState: Partial<{
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4744,7 +4913,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4782,6 +4951,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4813,8 +4983,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4842,6 +5010,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -4877,7 +5050,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4915,6 +5088,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -4946,8 +5120,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -4975,6 +5147,11 @@ declare const useManagedDataSource: (props: object) => {
             sortInfo: never;
             rowDisabledState: never;
         } & {
+            logger: DebugLogger;
+            forceRerenderTimestamp: number;
+            devToolsDetected: never;
+            debugTimings: Map<DebugTimingKey, number>;
+            debugWarnings: Map<"DS001", DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
             __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5010,7 +5187,7 @@ declare const useManagedDataSource: (props: object) => {
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5048,6 +5225,7 @@ declare const useManagedDataSource: (props: object) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            debugId: never;
             isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5079,8 +5257,6 @@ declare const useManagedDataSource: (props: object) => {
             isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
             onNodeCollapse: never;
             onNodeExpand: never;
-            debugId: never;
-            debugMode: never;
             nodesKey: string;
             treeSelection: never;
             batchOperationDelay: never;
@@ -5110,6 +5286,11 @@ declare const useManagedDataSource: (props: object) => {
         }>) => void;
     };
     ContextComponent: React$1.Context<ManagedComponentStateContextValue<{
+        logger: DebugLogger;
+        forceRerenderTimestamp: number;
+        devToolsDetected: never;
+        debugTimings: Map<DebugTimingKey, number>;
+        debugWarnings: Map<"DS001", DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
         __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5145,7 +5326,7 @@ declare const useManagedDataSource: (props: object) => {
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5183,6 +5364,7 @@ declare const useManagedDataSource: (props: object) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        debugId: never;
         isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5214,8 +5396,6 @@ declare const useManagedDataSource: (props: object) => {
         isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
         onNodeCollapse: never;
         onNodeExpand: never;
-        debugId: never;
-        debugMode: never;
         nodesKey: string;
         treeSelection: never;
         batchOperationDelay: never;
@@ -5243,6 +5423,11 @@ declare const useManagedDataSource: (props: object) => {
         sortInfo: never;
         rowDisabledState: never;
     } & {
+        logger: DebugLogger;
+        forceRerenderTimestamp: number;
+        devToolsDetected: never;
+        debugTimings: Map<DebugTimingKey, number>;
+        debugWarnings: Map<"DS001", DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
         __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5278,7 +5463,7 @@ declare const useManagedDataSource: (props: object) => {
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5316,6 +5501,7 @@ declare const useManagedDataSource: (props: object) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        debugId: never;
         isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5347,8 +5533,6 @@ declare const useManagedDataSource: (props: object) => {
         isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
         onNodeCollapse: never;
         onNodeExpand: never;
-        debugId: never;
-        debugMode: never;
         nodesKey: string;
         treeSelection: never;
         batchOperationDelay: never;
@@ -5376,6 +5560,11 @@ declare const useManagedDataSource: (props: object) => {
         sortInfo: never;
         rowDisabledState: never;
     } & {
+        logger: DebugLogger;
+        forceRerenderTimestamp: number;
+        devToolsDetected: never;
+        debugTimings: Map<DebugTimingKey, number>;
+        debugWarnings: Map<"DS001", DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
         __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5411,7 +5600,7 @@ declare const useManagedDataSource: (props: object) => {
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5449,6 +5638,7 @@ declare const useManagedDataSource: (props: object) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        debugId: never;
         isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5480,8 +5670,6 @@ declare const useManagedDataSource: (props: object) => {
         isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
         onNodeCollapse: never;
         onNodeExpand: never;
-        debugId: never;
-        debugMode: never;
         nodesKey: string;
         treeSelection: never;
         batchOperationDelay: never;
@@ -5509,6 +5697,11 @@ declare const useManagedDataSource: (props: object) => {
         sortInfo: never;
         rowDisabledState: never;
     }, ComponentStateGeneratedActions<{
+        logger: DebugLogger;
+        forceRerenderTimestamp: number;
+        devToolsDetected: never;
+        debugTimings: Map<DebugTimingKey, number>;
+        debugWarnings: Map<"DS001", DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
         __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5544,7 +5737,7 @@ declare const useManagedDataSource: (props: object) => {
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5582,6 +5775,7 @@ declare const useManagedDataSource: (props: object) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        debugId: never;
         isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5613,8 +5807,6 @@ declare const useManagedDataSource: (props: object) => {
         isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
         onNodeCollapse: never;
         onNodeExpand: never;
-        debugId: never;
-        debugMode: never;
         nodesKey: string;
         treeSelection: never;
         batchOperationDelay: never;
@@ -5642,6 +5834,11 @@ declare const useManagedDataSource: (props: object) => {
         sortInfo: never;
         rowDisabledState: never;
     } & {
+        logger: DebugLogger;
+        forceRerenderTimestamp: number;
+        devToolsDetected: never;
+        debugTimings: Map<DebugTimingKey, number>;
+        debugWarnings: Map<"DS001", DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
         __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5677,7 +5874,7 @@ declare const useManagedDataSource: (props: object) => {
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5715,6 +5912,7 @@ declare const useManagedDataSource: (props: object) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        debugId: never;
         isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5746,8 +5944,6 @@ declare const useManagedDataSource: (props: object) => {
         isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
         onNodeCollapse: never;
         onNodeExpand: never;
-        debugId: never;
-        debugMode: never;
         nodesKey: string;
         treeSelection: never;
         batchOperationDelay: never;
@@ -5775,6 +5971,11 @@ declare const useManagedDataSource: (props: object) => {
         sortInfo: never;
         rowDisabledState: never;
     } & {
+        logger: DebugLogger;
+        forceRerenderTimestamp: number;
+        devToolsDetected: never;
+        debugTimings: Map<DebugTimingKey, number>;
+        debugWarnings: Map<"DS001", DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
         __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
@@ -5810,7 +6011,7 @@ declare const useManagedDataSource: (props: object) => {
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "debugId" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "treeFilterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "defaultGroupBy" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "onGroupByChange" | "onLivePaginationCursorChange" | "onPivotByChange" | "defaultPivotBy" | "defaultRowSelection" | "fields" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultAggregationReducers" | "defaultSortInfo" | "onSortInfoChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -5848,6 +6049,7 @@ declare const useManagedDataSource: (props: object) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        debugId: never;
         isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
@@ -5879,8 +6081,6 @@ declare const useManagedDataSource: (props: object) => {
         isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
         onNodeCollapse: never;
         onNodeExpand: never;
-        debugId: never;
-        debugMode: never;
         nodesKey: string;
         treeSelection: never;
         batchOperationDelay: never;
@@ -6031,6 +6231,7 @@ type InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> = {
     rowDetailState: false | 'expanded' | 'collapsed';
     isGroupRow: true;
     isTreeNode: false;
+    isParentNode: false;
     field?: keyof T;
     value: any;
     rawValue: any;
@@ -6729,6 +6930,7 @@ interface InfiniteTableApi<T> {
     getState: () => InfiniteTableState<T>;
     getDataSourceState: () => DataSourceState<T>;
     focus: () => void;
+    setGroupRenderStrategy: (groupRenderStrategy: InfiniteTablePropGroupRenderStrategy) => void;
 }
 type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
 type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = Record<string, ColumnType>;
@@ -6831,7 +7033,6 @@ type InfiniteTablePropKeyboardShorcut = {
         stopNext: boolean;
     } | Promise<any>;
 };
-type InfiniteTablePropDebugMode = boolean;
 type InfiniteTablePropOnCellDoubleClickResult = Partial<{
     preventEdit: boolean;
 }>;
@@ -6850,7 +7051,6 @@ interface InfiniteTableProps<T> {
     loadingText?: Renderable;
     components?: InfiniteTablePropComponents<T>;
     wrapRowsHorizontally?: boolean;
-    debugMode?: InfiniteTablePropDebugMode;
     keyboardShortcuts?: InfiniteTablePropKeyboardShorcut[];
     repeatWrappedGroupRows?: InfiniteTablePropRepeatWrappedGroupRows<T>;
     viewportReservedWidth?: number;
@@ -7012,6 +7212,8 @@ interface InfiniteTableProps<T> {
     columnOrder?: InfiniteTablePropColumnOrder;
     onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrderNormalized) => void;
     onRowHeightChange?: (rowHeight: number) => void;
+    onRowMouseEnter?: (context: InfiniteTableRowContext<T>, event: React$1.MouseEvent) => void;
+    onRowMouseLeave?: (context: InfiniteTableRowContext<T>, event: React$1.MouseEvent) => void;
     onReady?: ({ api, dataSourceApi, }: {
         api: InfiniteTableApi<T>;
         dataSourceApi: DataSourceApi<T>;
@@ -7123,7 +7325,8 @@ declare class DataQuery {
     private doneAt;
     private pendingPromise;
     debugName: string;
-    constructor(debugName?: string);
+    private logger;
+    constructor(debugName: string);
     fetch: (loadFn: DataQueryFn, ...key: DataQueryKey[]) => Promise<DataQuerySnapshot>;
     getCurrentSnapshot: () => DataQuerySnapshot;
     getDoneSnapshot: () => Promise<DataQuerySnapshot>;
@@ -7245,4 +7448,4 @@ declare const components: {
     NumberFilterEditor: typeof NumberFilterEditor;
 };
 
-export { AdvancedAlignable, CellSelectionState, CellSelectionStateObject, ColumnTypeWithInherit, DataClient, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceApi, DataSourceCRUDParam, DataSourceCallback_BaseParam, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceInsertParam, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourceMasterDetailContextValue, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropCellSelection_MultiCell, DataSourcePropCellSelection_SingleCell, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsNodeExpanded, DataSourcePropIsNodeReadOnly, DataSourcePropIsNodeSelectable, DataSourcePropIsNodeSelected, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnCellSelectionChange_MultiCell, DataSourcePropOnCellSelectionChange_SingleCell, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropOnTreeSelectionChange, DataSourcePropOnTreeSelectionChange_MultiNode, DataSourcePropOnTreeSelectionChange_SingleNode, DataSourcePropPivotBy, DataSourcePropRowInfoReducers, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropShouldReloadData, DataSourcePropShouldReloadDataObject, DataSourcePropSortFn, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourcePropTreeFilterFunction, DataSourcePropTreeSelection, DataSourcePropTreeSelection_MultiNode, DataSourcePropTreeSelection_SingleNode, DataSourceProps, DataSourcePropsNotAvailableInTreeDataSource, DataSourcePropsWithChildren, DataSourceRawReducer, DataSourceRemoteData, DataSourceRowInfoReducer, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, DataSourceUpdateParam, DebugLogger, DeepMap, ElementContainerGetter, FixedSizeSet, FlashingColumnCell, GroupRowsState, InfiniteColumnEditorContextType, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableCellSelectionApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnApi, InfiniteTableColumnCellContextType, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderFunctionForGroupRows, InfiniteTableColumnRenderFunctionForNormalRows, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnValueFormatterParams, InfiniteTableColumnValueGetterParams, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTableKeyboardNavigationApi, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroupVisibility, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropGetCellContextMenuItems, InfiniteTablePropGetColumnMenuItems, InfiniteTablePropGetContextMenuItems, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropKeyboardShorcut, InfiniteTablePropMultiSortBehavior, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTablePropsNotAvailableInTreeGrid, InfiniteTableRowClassNameFn, InfiniteTableRowDetailApi, InfiniteTableRowInfo, InfiniteTableRowSelectionApi, InfiniteTableRowStyleFn, InfiniteTableState, InfiniteTable_HasGrouping_RowInfoGroup, InfiniteTable_HasGrouping_RowInfoNormal, InfiniteTable_Tree_RowInfoLeafNode, InfiniteTable_Tree_RowInfoNode, InfiniteTable_Tree_RowInfoParentNode, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, Menu, MenuChildrenFnParam, MenuColumn, MenuColumnRenderParam, MenuDecoration, MenuIconProps, MenuItemActionContext, MenuItemDefinition, MenuItemObject, MenuProps, MenuRenderable, MenuRuntimeItem, MenuRuntimeItemSelectable, MenuSeparator, OverlayShowParams, RowDetailCache, RowDetailState, RowDetailStateObject, RowDisabledState, RowDisabledStateObject, RowSelectionState, ScrollStopInfo, Scrollbars, ShowOverlayFn, TableRenderRange, TreeDataSource, TreeDataSourceProps, TreeExpandState, TreeExpandStateValue, TreeGrid, TreeGridOnlyProps, TreeGridProps, TreeSelectionState, TreeSelectionValue, UpdateChildrenFn, UpdateOverlayContentFn, WaitForNodeOptions, WeakFixedSizeSet, alignNode, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, 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, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes };
+export { AdvancedAlignable, CellSelectionState, CellSelectionStateObject, ColumnTypeWithInherit, DataClient, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceApi, DataSourceCRUDParam, DataSourceCallback_BaseParam, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDebugWarningKey, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceInsertParam, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourceMasterDetailContextValue, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropCellSelection_MultiCell, DataSourcePropCellSelection_SingleCell, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsNodeExpanded, DataSourcePropIsNodeReadOnly, DataSourcePropIsNodeSelectable, DataSourcePropIsNodeSelected, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnCellSelectionChange_MultiCell, DataSourcePropOnCellSelectionChange_SingleCell, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropOnTreeSelectionChange, DataSourcePropOnTreeSelectionChange_MultiNode, DataSourcePropOnTreeSelectionChange_SingleNode, DataSourcePropPivotBy, DataSourcePropRowInfoReducers, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropShouldReloadData, DataSourcePropShouldReloadDataObject, DataSourcePropSortFn, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourcePropTreeFilterFunction, DataSourcePropTreeSelection, DataSourcePropTreeSelection_MultiNode, DataSourcePropTreeSelection_SingleNode, DataSourceProps, DataSourcePropsNotAvailableInTreeDataSource, DataSourcePropsWithChildren, DataSourceRawReducer, DataSourceRemoteData, DataSourceRowInfoReducer, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, DataSourceUpdateParam, DebugLogger, DebugTimingKey, DebugWarningPayload, DeepMap, DevToolsDataSourceOverrides, DevToolsGenericMessage, DevToolsHookFn, DevToolsHookFnOptions, DevToolsHostPageLogMessage, DevToolsHostPageLogMessagePayload, DevToolsHostPageMessage, DevToolsHostPageMessagePayload, DevToolsHostPageMessageType, DevToolsInfiniteOverrides, DevToolsMessageAddress, DevToolsOverrides, ElementContainerGetter, ErrorCodeKey, FixedSizeSet, FlashingColumnCell, GroupRowsState, InfiniteColumnEditorContextType, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableCellSelectionApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnApi, InfiniteTableColumnCellContextType, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderFunctionForGroupRows, InfiniteTableColumnRenderFunctionForNormalRows, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnValueFormatterParams, InfiniteTableColumnValueGetterParams, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableDebugWarningKey, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTableKeyboardNavigationApi, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroupVisibility, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropGetCellContextMenuItems, InfiniteTablePropGetColumnMenuItems, InfiniteTablePropGetContextMenuItems, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropKeyboardShorcut, InfiniteTablePropMultiSortBehavior, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTablePropsNotAvailableInTreeGrid, InfiniteTableRowClassNameFn, InfiniteTableRowDetailApi, InfiniteTableRowInfo, InfiniteTableRowSelectionApi, InfiniteTableRowStyleFn, InfiniteTableState, InfiniteTable_HasGrouping_RowInfoGroup, InfiniteTable_HasGrouping_RowInfoNormal, InfiniteTable_Tree_RowInfoLeafNode, InfiniteTable_Tree_RowInfoNode, InfiniteTable_Tree_RowInfoParentNode, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, Menu, MenuChildrenFnParam, MenuColumn, MenuColumnRenderParam, MenuDecoration, MenuIconProps, MenuItemActionContext, MenuItemDefinition, MenuItemObject, MenuProps, MenuRenderable, MenuRuntimeItem, MenuRuntimeItemSelectable, MenuSeparator, OverlayShowParams, RowDetailCache, RowDetailState, RowDetailStateObject, RowDisabledState, RowDisabledStateObject, RowSelectionState, ScrollStopInfo, Scrollbars, ShowOverlayFn, TableRenderRange, TreeDataSource, TreeDataSourceProps, TreeExpandState, TreeExpandStateValue, TreeGrid, TreeGridOnlyProps, TreeGridProps, TreeSelectionState, TreeSelectionValue, UpdateChildrenFn, UpdateOverlayContentFn, WaitForNodeOptions, WeakFixedSizeSet, alignNode, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, 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, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes };