@infinite-table/infinite-react 8.0.5 → 9.0.0-canary.0

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as React$1 from 'react';
-import React__default, { RefCallback, CSSProperties, HTMLProps, MutableRefObject, MouseEvent, KeyboardEvent, HTMLAttributes, ReactNode, EffectCallback, DependencyList } from 'react';
+import React__default, { CSSProperties, HTMLProps, KeyboardEvent, HTMLAttributes, MutableRefObject, MouseEvent, ReactNode, EffectCallback, DependencyList } from 'react';
 
 type ManagedComponentStateContextValue<T_STATE, T_ACTIONS> = {
     getComponentState: () => T_STATE;
@@ -9,7 +9,7 @@ type ManagedComponentStateContextValue<T_STATE, T_ACTIONS> = {
     replaceState: (state: T_STATE) => void;
 };
 type ComponentStateGeneratedActions<T_STATE> = {
-    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
+    [k in keyof T_STATE]: T_STATE[k] | ((prevState: T_STATE[k]) => T_STATE[k]);
 };
 type ComponentInterceptedActions<T_STATE> = {
     [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
@@ -323,9 +323,6 @@ type TreeGridOnlyProps<_T> = {};
 type InfiniteTablePropsNotAvailableInTreeGrid = keyof Pick<InfiniteTableProps<any>, 'pivotColumns' | 'pivotColumnGroups' | 'pivotTotalColumnPosition' | 'pivotGrandTotalColumnPosition' | 'groupColumn' | 'groupRenderStrategy' | 'hideEmptyGroupColumns' | 'showSeparatePivotColumnForSingleAggregation' | 'isRowDetailExpanded' | 'isRowDetailEnabled' | 'rowDetailCache' | 'rowDetailState' | 'defaultRowDetailState' | 'onRowDetailStateChange' | 'rowDetailHeight' | 'rowDetailRenderer' | 'groupRenderStrategy'>;
 type TreeGridProps<T> = Omit<InfiniteTableProps<T>, InfiniteTablePropsNotAvailableInTreeGrid> & TreeGridOnlyProps<T>;
 
-declare function TreeGrid<T>(props: TreeGridProps<T>): React$1.JSX.Element;
-declare const withSelectedLeafNodesOnly: (callback: (treeSelectionObject: TreeSelectionStateObject) => void) => DataSourcePropOnTreeSelectionChange_MultiNode;
-
 type DebugLogger = {
     (...args: any[]): void;
     extend: (channelName: string) => DebugLogger;
@@ -369,218 +366,18 @@ declare class Logger {
     constructor(channelName: string);
 }
 
-interface Size {
-    width: number;
-    height: number;
-}
-
 interface ScrollPosition {
     scrollTop: number;
     scrollLeft: number;
 }
 type OnScrollFn = (scrollPosition: ScrollPosition) => void;
 
-type RenderRange = {
-    renderStartIndex: number;
-    renderEndIndex: number;
-};
-
-type VoidFn = () => void;
-
-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;
-    getListenersCount: () => number;
-}
-
-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, originalData: DataType, metadata: any) => void;
-    insert: (primaryKey: PrimaryKeyType, data: DataType, position: "before" | "after", metadata: any) => void;
-    insertNodePath: (nodePath: NodePath$1, data: DataType, position: "before" | "after", metadata: any) => void;
-    update: (primaryKey: PrimaryKeyType, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
-    updateNodePath: (nodePath: NodePath$1, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
-    updateChildren: (nodePath: NodePath$1, 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) => void;
-    getMutationsForPrimaryKey: (primaryKey: PrimaryKeyType) => DataSourceMutation<DataType>[] | undefined;
-    getMutationsForNodePath: (nodePath: NodePath$1) => DataSourceMutation<DataType>[] | undefined;
-    getMutationsCount: () => number;
-    getMutations: () => Map<PrimaryKeyType, DataSourceMutation<DataType>[]>;
-    getTreeMutations: () => DeepMap<NodePath$1, 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;
-    Context?: React$1.Context<ManagedComponentStateContextValue<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE, ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & 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>(Context?: React$1.Context<ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateActions<COMPONENT_STATE>>>): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
-
-type PerfMarkerDetails = {
-    name: string;
-    value: string | number | boolean;
-}[];
-interface PerfMarker {
-    start(options?: {
-        details?: PerfMarkerDetails;
-    }): PerfMarker;
-    end(options?: {
-        details?: PerfMarkerDetails;
-    }): PerfMarker;
+interface Size {
+    width: number;
+    height: number;
 }
 
-interface RowInfoStore<T> {
-    /**
-     * Update the entire dataArray (called from reducer)
-     * Compares old vs new rowInfo at each index and notifies subscribers for changed indices
-     */
-    notifyDataArray(newDataArray: InfiniteTableRowInfo<T>[], params?: {
-        marker?: PerfMarker;
-    }): void;
-    /**
-     * Get current rowInfo at index (snapshot for useSyncExternalStore)
-     */
-    getRowInfoAtIndex(index: number): InfiniteTableRowInfo<T> | undefined;
-    /**
-     * Subscribe to changes at a specific row index
-     * Returns unsubscribe function
-     */
-    subscribeToRowIndex(rowIndex: number, callback: () => void): () => void;
-    /**
-     * Get current dataArray (for components that need full array)
-     */
-    getDataArray(): InfiniteTableRowInfo<T>[];
-    /**
-     * Clear the store (reset dataArray and remove all subscribers)
-     */
-    clear(): void;
-}
+type VoidFn = () => void;
 
 type TableRenderRange = {
     start: [number, number];
@@ -1018,373 +815,124 @@ declare class Point {
     };
 }
 
-interface RowDetailCacheStorage<_K, T> {
-    add(key: any, value: T): void;
-    get(key: any): T | undefined;
-    delete(key: any): void;
-    has(key: any): boolean;
-}
-interface RowDetailCacheStorageForCurrentRow<T = RowDetailCacheEntry> {
-    add(value: T): void;
-    get(): T | undefined;
-    delete(): void;
-    has(): boolean;
-}
-declare class RowDetailCache<K = RowDetailCacheKey, T = RowDetailCacheEntry> implements RowDetailCacheStorage<K, T> {
-    private cacheStorage;
-    constructor(cache?: boolean | number);
-    add(key: K, value: T): void;
-    get(key: K): T | undefined;
-    delete(key: K): void;
-    has(key: K): boolean;
-}
-
-type BooleanCollectionStateKeys<KeyType> = true | KeyType[];
-type BooleanCollectionStateObject<KeyType> = {
-    positiveItems: BooleanCollectionStateKeys<KeyType>;
-    negativeItems: BooleanCollectionStateKeys<KeyType>;
+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]);
 };
-declare abstract class BooleanCollectionState<StateObject, KeyType> {
-    protected positiveMap?: Map<KeyType, true>;
-    protected negativeMap?: Map<KeyType, true>;
-    protected allNegative: boolean;
-    protected allPositive: boolean;
-    private initialState;
-    constructor(state: BooleanCollectionStateObject<KeyType> | BooleanCollectionState<StateObject, KeyType>);
-    abstract getPositiveFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
-    abstract getNegativeFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
-    abstract getState(): StateObject;
-    protected getInitialState(): BooleanCollectionStateObject<KeyType>;
-    destroy(): void;
-    private update;
-    protected isDefaultNegativeSelection(): boolean;
-    protected isDefaultPositiveSelection(): boolean;
-    protected areAllNegative(): boolean;
-    protected areAllPositive(): boolean;
-    protected makeAllNegative(): void;
-    protected makeAllPositive(): void;
-    protected isItemPositive(key: KeyType): boolean;
-    protected isItemNegative(key: KeyType): boolean;
-    protected setItemValue(key: KeyType, shouldMakePositive: boolean): void;
-    protected makeItemNegative(key: KeyType): void;
-    protected makeItemPositive(key: KeyType): void;
-    protected toggleItem(key: KeyType): void;
-}
-
-declare class RowDetailState<KeyType = any> extends BooleanCollectionState<RowDetailStateObject<KeyType>, KeyType> {
-    constructor(state: RowDetailStateObject<KeyType> | RowDetailState<KeyType>);
-    getState(): RowDetailStateObject<KeyType>;
-    getPositiveFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
-    getNegativeFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
-    areAllCollapsed(): boolean;
-    areAllExpanded(): boolean;
-    collapseAll(): void;
-    expandAll(): void;
-    isRowDetailsExpanded: (key: KeyType) => boolean;
-    isRowDetailsCollapsed(key: KeyType): boolean;
-    setRowDetailsExpanded(key: KeyType, shouldExpand: boolean): void;
-    collapseRowDetails(key: KeyType): void;
-    expandRowDetails(key: KeyType): void;
-    toggleRowDetails(key: KeyType): void;
-}
 
-type Renderable = React$1.ReactNode | React$1.JSX.Element;
+/**
+ * React adapter for the managed component state system.
+ *
+ * All framework-free logic (controlled/uncontrolled resolution, reducer body,
+ * generated action setters, prop-diff) lives in ./managedComponentState.ts.
+ * This file owns React scheduling: useState/useReducer, effects, context.
+ * Its behavior is pinned by buildManagedComponent.jestspec.tsx.
+ */
 
-type TableRenderCellFnParam = {
-    domRef: RefCallback<HTMLElement>;
-    rowIndex: number;
-    colIndex: number;
-    rowspan: number;
-    colspan: number;
-    hidden: boolean;
-    width: number;
-    height: number;
-    widthWithColspan: number;
-    heightWithRowspan: number;
-    rowFixed: FixedPosition;
-    colFixed: FixedPosition;
-    onMouseEnter: (event: React.MouseEvent<HTMLElement>) => void;
-    onMouseLeave: (event: React.MouseEvent<HTMLElement>) => void;
-};
-type TableRenderDetailRowFnParam = {
-    domRef: RefCallback<HTMLElement>;
-    rowIndex: number;
-    hidden: boolean;
-    height: number;
-    rowFixed: FixedPosition;
-    onMouseEnter: (event: React.MouseEvent<HTMLElement>) => void;
-    onMouseLeave: (event: React.MouseEvent<HTMLElement>) => void;
-};
-type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
-type TableRenderDetailRowFn = (param: TableRenderDetailRowFnParam) => Renderable;
-type RenderRangeOptions = {
-    force?: boolean;
-    renderCell: TableRenderCellFn;
-    renderDetailRow?: TableRenderDetailRowFn;
-    onRender: (items: Renderable[]) => void;
+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;
+    Context?: React$1.Context<ManagedComponentStateContextValue<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE, ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & 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);
 };
-type HorizontalLayoutColVisibilityOptions = {
-    horizontalLayoutPageIndex?: number;
+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>(Context?: React$1.Context<ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateActions<COMPONENT_STATE>>>): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
 
-interface GridCellInterface<T_ADDITIONAL_CELL_INFO = any> {
-    debugId: string;
-    update(content: Renderable, additionalInfo?: T_ADDITIONAL_CELL_INFO): void;
-    getElement(): HTMLElement | null;
-    getNode(): Renderable;
-    destroy(): void;
-    onMount(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
-    getAdditionalInfo(): T_ADDITIONAL_CELL_INFO | undefined;
-    isMounted(): boolean;
-    ref: React.RefCallback<HTMLElement | undefined>;
-    setPendingAfterCommitWork(fn: (() => void) | null): void;
+type PerfMarkerDetails = {
+    name: string;
+    value: string | number | boolean;
+}[];
+interface PerfMarker {
+    start(options?: {
+        details?: PerfMarkerDetails;
+    }): PerfMarker;
+    end(options?: {
+        details?: PerfMarkerDetails;
+    }): PerfMarker;
 }
 
-type CellPos = [number, number];
-
-declare class GridCellManager<T_ADDITIONAL_CELL_INFO> extends Logger {
-    private matrix;
-    private rowsWithCellsHistory;
-    private columnsWithCellsHistory;
-    private cellToMatrixPosition;
-    private pool;
-    debugId: string;
-    private offRemoveCell;
-    constructor(debugId: string);
-    private onRemoveCell;
-    set poolSize(cellCount: number);
-    get poolSize(): number;
-    getDetachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
-    private clearCellFromMatrix;
-    private addCellToMatrix;
-    private setCellPositionInMatrix;
-    renderNodeAtCell(node: Renderable, cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, cellPos: CellPos, additionalInfo?: T_ADDITIONAL_CELL_INFO): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
-    getCellPosition(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): CellPos | null;
-    getCellAt(cellPos: CellPos): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+interface RowInfoStore<T> {
     /**
-     * This gets a cell for a given position.
-     * If there's already a cell currently attached at that position, it will be returned.
-     *
-     * Otherwise, we try to return the most optimal cell to use for that position.
-     * If the optimise parameter is set to 'row', we will try to return a detached cell
-     * that was last rendered in that row.
-     *
-     * If the optimise parameter is set to 'column', we will try to return a detached cell
-     * that was last rendered in that column.
-     *
-     * @param cellPos [rowIndex, colIndex]
-     * @param optimise 'row' | 'column'
+     * Update the entire dataArray (called from reducer)
+     * Compares old vs new rowInfo at each index and notifies subscribers for changed indices
      */
-    getCellFor(cellPos: CellPos, optimise: 'row' | 'column'): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
-    isCellAttached(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
-    isCellAttachedAt(cellPos: CellPos): boolean;
-    getMatrix(): Renderable[][];
-    getAllCells(): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
-    getCellsForRow(rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
-    getOneAttachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    getRowsWithCells(): number[];
-    getColumnsWithCells(): number[];
-    isRowAttached(rowIndex: number): boolean;
-    isColumnAttached(colIndex: number): boolean;
-    detachRow(rowIndex: number): void;
-    detachCol(colIndex: number): void;
-    detachCell(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
-    detachCells(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>): void;
-    detachRowsStartingWith(rowIndex: number): void;
-    detachColsStartingWith(colIndex: number): void;
-    detachCellsStartingAt(cellPos: CellPos): void;
-    detachCellAt(cellPos: CellPos): boolean;
-    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFn;
-    getCellsOutsideRenderRange: (range: TableRenderRange) => Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
-    getCellFromListForRow(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    getCellFromListForColumn(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, colIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
-    getCellCountInMatrix(): number;
-    destroy(): void;
-    reset(): void;
-    makeDetachedCellsEmpty(): void;
-    withDetachedCells(fn: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
+    notifyDataArray(newDataArray: InfiniteTableRowInfo<T>[], params?: {
+        marker?: PerfMarker;
+    }): void;
+    /**
+     * Get current rowInfo at index (snapshot for useSyncExternalStore)
+     */
+    getRowInfoAtIndex(index: number): InfiniteTableRowInfo<T> | undefined;
+    /**
+     * Subscribe to changes at a specific row index
+     * Returns unsubscribe function
+     */
+    subscribeToRowIndex(rowIndex: number, callback: () => void): () => void;
+    /**
+     * Get current dataArray (for components that need full array)
+     */
+    getDataArray(): InfiniteTableRowInfo<T>[];
+    /**
+     * Clear the store (reset dataArray and remove all subscribers)
+     */
+    clear(): void;
 }
 
 /**
- * This is only used for rendering Detail rows in a master-detail DataGrid
+ * The type of a UI node the grid can render.
+ *
+ * NOTE (multi-framework): this file is the single intentional React type leak
+ * in the shared tree. When the first non-React framework lands (Phase 2 of the
+ * multi-framework plan), this gains framework siblings (Renderable.vue.ts, ...)
+ * resolved via `moduleSuffixes` (see tsconfig.react.json / tsconfig.vue.json)
+ * and the esbuild framework-resolve-plugin. Shared code must only treat
+ * Renderable as an opaque value to pass around — never inspect it.
  */
-interface ListRowInterface {
-    debugId: string;
-    update(content: Renderable): void;
-    getElement(): HTMLElement | null;
-    getNode(): Renderable;
-    destroy(): void;
-    onMount(callback: (row: ListRowInterface) => void): void;
-    isMounted(): boolean;
-    ref: (htmlElement: HTMLElement) => void;
-}
-
-declare class ListRowManager extends Logger {
-    private pool;
-    private indexToRow;
-    private rowToIndex;
-    debugId: string;
-    private offRemoveRow;
-    constructor(debugId: string);
-    private onRemoveRow;
-    set poolSize(rowCount: number);
-    get poolSize(): number;
-    getDetachedRow(): ListRowInterface;
-    /**
-     * This gets a row for a given position.
-     * If there's already a row currently attached at that position, it will be returned.
-     *
-     * Otherwise, we return another row.
-     * @param rowIndex
-     */
-    getRowFor(rowIndex: number): ListRowInterface;
-    private setRowIndexInList;
-    detachStartingWith(rowIndex: number): void;
-    getRowAt(rowPos: number): ListRowInterface | undefined;
-    getRowIndex(row: ListRowInterface): number | undefined;
-    isRowAttached(row: ListRowInterface): boolean;
-    isRowAttachedAt(rowIndex: number): boolean;
-    getList(): Renderable[];
-    getAttachedCount(): number;
-    forEachAttachedRow(fn: (row: ListRowInterface) => void): void;
-    getAttachedIndexes(): number[];
-    getAllRows(): ListRowInterface[];
-    detachRowAt(rowIndex: number): void;
-    detachRow(row: ListRowInterface): void;
-    renderNodeAtRow(node: Renderable, row: ListRowInterface, rowIndex: number): ListRowInterface;
-    makeDetachedRowsEmpty(): void;
-    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFn;
-    withDetachedRows(fn: (row: ListRowInterface) => void): void;
-    destroy(): void;
-    reset(): void;
-}
-
-declare class GridRenderer extends Logger {
-    protected brain: MatrixBrain;
-    debugId: string;
-    protected destroyed: boolean;
-    private scrolling;
-    cellHoverClassNames: string[];
-    cellDetachedClassNames: string[];
-    cellManager: GridCellManager<{
-        renderRowIndex: number;
-        renderColIndex: number;
-    }>;
-    protected rowManager: ListRowManager;
-    private lastEnteredRow;
-    private lastExitedRow;
-    private onDestroy;
-    private hoverRowUpdatesInProgress;
-    private infiniteNode;
-    private getInfiniteNode;
-    setDetailTransform: (element: HTMLElement, _rowIndex: number, { y, scrollTop, scrollLeft, }: {
-        y: number;
-        scrollTop?: boolean;
-        scrollLeft?: number;
-    }) => void;
-    setTransform: (element: HTMLElement, _rowIndex: number, colIndex: number, { x, y, scrollLeft, scrollTop, }: {
-        x: number;
-        y: number;
-        scrollLeft?: boolean;
-        scrollTop?: boolean;
-    }, zIndex: number | "auto" | undefined | null) => void;
-    constructor(brain: MatrixBrain, debugId?: string);
-    private onCellAttached;
-    private onCellDetached;
-    private onRowAttached;
-    private onRowDetached;
-    getFullyVisibleRowsRange: () => {
-        start: number;
-        end: number;
-    } | null;
-    getScrollPositionForScrollRowIntoView: (rowIndex: number, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-        colIndex?: number;
-    }) => ScrollPosition | null;
-    getScrollPositionForScrollColumnIntoView: (colIndex: number, config?: {
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offset?: number;
-    } & HorizontalLayoutColVisibilityOptions) => ScrollPosition | null;
-    getScrollPositionForScrollCellIntoView: (rowIndex: number, colIndex: number, config?: {
-        rowScrollAdjustPosition?: ScrollAdjustPosition;
-        colScrollAdjustPosition?: ScrollAdjustPosition;
-        scrollAdjustPosition?: ScrollAdjustPosition;
-        offsetTop: number;
-        offsetLeft: number;
-    }) => ScrollPosition | null;
-    isRowFullyVisible: (rowIndex: number, offsetMargin?: number) => boolean;
-    isRowVisible: (rowIndex: number, offsetMargin?: number) => boolean;
-    isRowRendered: (rowIndex: number) => boolean;
-    isCellVisible: (rowIndex: number, colIndex: number) => boolean;
-    isCellFullyVisible: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isColumnFullyVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isColumnVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isCellRendered: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    isColumnRendered: (colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
-    getExtraSpanCellsForRange: (range: TableRenderRange) => [number, number][];
-    isCellRenderedAndMappedCorrectly(row: number, col: number): {
-        rendered: boolean;
-        mapped: boolean;
-    };
-    renderRange(range: TableRenderRange, { renderCell, renderDetailRow, force, onRender }: RenderRangeOptions): Renderable[];
-    getFixedRanges: (currentRenderRange: TableRenderRange) => TableRenderRange[];
-    protected isCellFixed: (rowIndex: number, colIndex: number) => {
-        row: FixedPosition;
-        col: FixedPosition;
-    };
-    protected isCellCovered: (rowIndex: number, colIndex: number) => false | number[];
-    private renderDetailRowAtElement;
-    protected getCellRealCoordinates(rowIndex: number, colIndex: number): {
-        rowIndex: number;
-        colIndex: number;
-    };
-    protected onMouseEnterNotBound: (event: React.MouseEvent<HTMLElement>) => void;
-    protected onMouseLeaveNotBound: (event: React.MouseEvent<HTMLElement>) => void;
-    private getMatrixRowIndexFromElement;
-    protected renderCellAt(rowIndex: number, colIndex: number, cell: GridCellInterface, renderCell: TableRenderCellFn): void;
-    protected onMouseEnter: (rowIndex: number) => void;
-    private addHoverClass;
-    protected onMouseLeave: (rowIndex: number) => void;
-    private removeHoverClass;
-    protected updateHoverClassNamesForRow: (rowIndex: number) => void;
-    protected updateElementPosition: (cell: GridCellInterface<{
-        renderRowIndex: number;
-        renderColIndex: number;
-    }>, options?: {
-        hidden: boolean;
-        rowspan: number;
-        colspan: number;
-    }) => void;
-    private updateDetailElementPosition;
-    private onScrollStart;
-    private onScrollStop;
-    adjustFixedElementsOnScroll: (scrollPosition?: ScrollPosition) => void;
-    destroy: () => void;
-    reset(): void;
-}
-
-type CellPositionByIndex = {
-    rowIndex: number;
-    colIndex: number;
-};
-type MultiSelectRangeOptions = {
-    horizontalLayout: false;
-} | {
-    horizontalLayout: true;
-    rowsPerPage: number;
-    columnsPerSet: number;
-};
-
-declare class ScrollListener {
-    private scrollPosition;
-    private onScrollFns;
-    getScrollPosition: () => ScrollPosition;
-    onScroll: (fn: OnScrollFn) => () => void;
-    setScrollPosition: (scrollPosition: ScrollPosition) => void;
-    private notifyScrollChange;
-    destroy: () => void;
-}
+type Renderable = React$1.ReactNode | React$1.JSX.Element;
 
 type DiscriminatedUnion<A, B> = (A & {
     [K in keyof B]?: undefined;
@@ -1716,67 +1264,718 @@ type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'defaul
     groupByForColumn: GroupBy<T> | GroupBy<T>[];
     id?: string;
 };
-type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
-type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotTotalColumnGroup?: true;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex: PivotBy<DataType, KeyType>;
-    pivotGroupKey: KeyType;
-    pivotIndex: number;
+type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
+type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotTotalColumnGroup?: true;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex: PivotBy<DataType, KeyType>;
+    pivotGroupKey: KeyType;
+    pivotIndex: number;
+};
+type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotColumn: true;
+    pivotTotalColumn: boolean;
+    pivotAggregator: AggregationReducer<DataType, any>;
+    pivotAggregatorIndex: number;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex?: PivotBy<DataType, KeyType>;
+    pivotIndex: number;
+    pivotGroupKey: KeyType;
+};
+type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
+type InfiniteTableComputedColumnBase<T> = {
+    computedFilterType: string;
+    computedSortType: string | string[];
+    computedDataType: string;
+    computedWidth: number;
+    computedFlex: number | null;
+    computedMinWidth: number;
+    computedMaxWidth: number;
+    computedOffset: number;
+    computedPinningOffset: number;
+    computedAbsoluteOffset: number;
+    computedSortInfo: DataSourceSingleSortInfo<T> | null;
+    computedSorted: boolean;
+    computedSortedAsc: boolean;
+    computedSortedDesc: boolean;
+    computedSortIndex: number;
+    computedVisible: boolean;
+    computedVisibleIndex: number;
+    computedVisibleIndexInCategory: number;
+    computedMultiSort: boolean;
+    computedFiltered: boolean;
+    computedFilterable: boolean;
+    computedGroupedBy: boolean;
+    computedGroupedByIndex: number | undefined;
+    computedGroupable: boolean;
+    computedFilterValue: DataSourceFilterValueItem<T> | null;
+    computedPinned: InfiniteTableColumnPinnedValues;
+    computedDraggable: boolean;
+    computedResizable: boolean;
+    computedFirstInCategory: boolean;
+    computedLastInCategory: boolean;
+    computedFirst: boolean;
+    computedLast: boolean;
+    computedEditable: NonUndefined<InfiniteTableColumn<T>['defaultEditable']>;
+    computedSortable: NonUndefined<InfiniteTableColumn<T>['defaultSortable']>;
+    colType: InfiniteTableColumnType<T>;
+    id: string;
+};
+type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
+type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
+
+type InfiniteTableBaseCellProps<T> = {
+    column: InfiniteTableComputedColumn<T>;
+    align?: InfiniteTableColumnAlignValues;
+    horizontalLayoutPageIndex: number | null;
+    rowId?: any;
+    renderChildren: React.ReactNode | (() => Renderable);
+    width: number;
+    cssEllipsis?: boolean;
+    contentStyle?: CSSProperties;
+    contentClassName?: string;
+    virtualized?: boolean;
+    skipColumnShifting?: boolean;
+    beforeChildren?: Renderable;
+    afterChildren?: Renderable;
+    cssPosition?: CSSProperties['position'];
+    domRef?: React.RefCallback<HTMLElement>;
+    repaintId?: number | string;
+};
+type InfiniteTableCellProps<T> = ({
+    cellType: 'header';
+} & InfiniteTableBaseCellProps<T>) | ({
+    cellType: 'body';
+} & InfiniteTableBaseCellProps<T>);
+
+declare function useInfiniteHeaderCell<T>(): {
+    dragging: boolean;
+    column: InfiniteTableComputedColumn<T>;
+    columnsMap: Map<string, InfiniteTableComputedColumn<T>>;
+    columnSortInfo: DataSourceSingleSortInfo<T> | null;
+    columnFilterValue: DataSourceFilterValueItem<T> | null;
+    selectionMode: DataSourcePropSelectionMode;
+    horizontalLayoutPageIndex: null | number;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    filtered: boolean;
+    api: InfiniteTableApi<T>;
+    dataSourceApi: DataSourceApi<T>;
+    columnApi: InfiniteTableColumnApi<T>;
+    renderBag: {
+        all?: Renderable;
+        header: string | number | Renderable;
+        sortIcon?: Renderable;
+        menuIcon?: Renderable;
+        menuIconProps?: MenuIconProps;
+        filterIcon?: Renderable;
+        filterEditor?: Renderable;
+        selectionCheckBox?: Renderable;
+    };
+} & {
+    domRef: InfiniteTableCellProps<DATA_TYPE>["domRef"];
+    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
+    renderLocation: "column-header";
+} & {
+    domRef: InfiniteTableCellProps<DATA_TYPE_1>["domRef"];
+    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
+    renderLocation: "column-header";
+};
+
+declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
+declare function useInfiniteColumnEditor<T>(): InfiniteColumnEditorContextType<T>;
+
+declare function useInfiniteColumnFilterEditor<T>(): {
+    api: InfiniteTableApi<T>;
+    column: InfiniteTableComputedColumn<T>;
+    columnFilterValue: DataSourceFilterValueItem<any> | null;
+    columnApi: InfiniteTableColumnApi<T>;
+    operatorName: string | undefined;
+    operator: DataSourceFilterOperator<any> | undefined;
+    value: any;
+    disabled: boolean | undefined;
+    filterType: DataSourceFilterType<any>;
+    filterTypes: DataSourcePropFilterTypes<any>;
+    filterTypeKey: string;
+    filtered: boolean;
+    setValue: (filterValue: any) => void;
+    clearValue: () => void;
+    removeColumnFilter: () => void;
+    ariaLabel: string;
+    className: string;
+};
+
+type HotKeyEventDescriptor = {
+    key: KeyboardEvent['key'];
+    metaKey: KeyboardEvent['metaKey'];
+    altKey: KeyboardEvent['altKey'];
+    ctrlKey: KeyboardEvent['ctrlKey'];
+    shiftKey: KeyboardEvent['shiftKey'];
+};
+declare function eventMatchesKeyboardShortcut(event: HotKeyEventDescriptor, keyDescriptors: string | string[]): boolean;
+
+declare function HScrollSyncContent(props: HTMLAttributes<HTMLDivElement> & {
+    width?: 'viewport' | 'column';
+    maxWidth?: 'viewport' | 'column';
+    minWidth?: 'viewport' | 'column';
+    scrollable?: boolean;
+}): React$1.JSX.Element;
+
+declare function useGridScroll(onScroll: (scrollPosition: ScrollPosition) => void, deps: any[]): void;
+
+declare function useVisibleColumnSizes<T>(): {
+    id: string;
+    width: number;
+    cssVarForWidth: string;
+    offset: number;
+    cssVarForOffset: string;
+    pinned: InfiniteTableColumnPinnedValues;
+}[];
+
+declare function useInfinitePortalContainer(): HTMLDivElement | null;
+
+declare function HostDefault(props: {
+    active: boolean;
+    orientation: 'horizontal' | 'vertical';
+    rejectDrop: boolean;
+    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
+}): React$1.JSX.Element;
+declare function PlaceholderDefault<T = any>(props: {
+    draggingInProgress: boolean;
+    active: boolean;
+    groupBy: DataSourcePropGroupBy<T>;
+}): React$1.ReactNode;
+declare function GroupingToolbarItemDefault<T = any>(props: {
+    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
+    column: InfiniteTableComputedColumn<T> | undefined;
+    field: string | number | undefined;
+    active: boolean;
+    label: React$1.ReactNode;
+    onClear: () => void;
+}): React$1.JSX.Element;
+
+type GroupingToolbarProps = {
+    orientation?: 'horizontal' | 'vertical';
+    placeholder?: <T = any>(params: {
+        draggingInProgress: boolean;
+        active: boolean;
+        groupBy: DataSourcePropGroupBy<T>;
+    }) => React$1.ReactNode;
+    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
+    components?: {
+        Host?: typeof HostDefault;
+        Placeholder?: typeof PlaceholderDefault;
+        ToolbarItem?: typeof GroupingToolbarItemDefault;
+    };
+};
+declare function GroupingToolbar<T = any>(props: GroupingToolbarProps): React$1.JSX.Element;
+
+type InfiniteTableHeaderProps<_T> = {
+    allowColumnHideWhileDragging?: boolean;
+};
+
+type InfiniteTableBodyProps<_T> = {
+    rowHoverClassName?: string | string[];
+};
+
+declare function InfiniteTableBody<T>(props: InfiniteTableBodyProps<T>): React$1.JSX.Element;
+declare namespace InfiniteTableBody {
+    var rowHoverClassName: string[];
+}
+
+declare function useInfiniteTableApi<T>(): InfiniteTableApi<T>;
+
+declare function useInfiniteColumnApi<T = unknown>(columnId: string): InfiniteTableColumnApi<T> | null;
+
+declare const InfiniteTableClassName: string;
+declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => React$1.JSX.Element)>;
+type InfiniteTableComponent = {
+    <T>(props: InfiniteTableProps<T>): React$1.JSX.Element;
+    licenseKey?: string;
+    Header: <T = any>(props: InfiniteTableHeaderProps<T>) => React$1.JSX.Element | null;
+    Body: typeof InfiniteTableBody;
+    Footer: () => React$1.JSX.Element | null;
+    HScrollSyncContent: typeof HScrollSyncContent;
+    GroupingToolbar: typeof GroupingToolbar;
+};
+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;
+};
+
+interface RowDetailCacheStorage<_K, T> {
+    add(key: any, value: T): void;
+    get(key: any): T | undefined;
+    delete(key: any): void;
+    has(key: any): boolean;
+}
+interface RowDetailCacheStorageForCurrentRow<T = RowDetailCacheEntry> {
+    add(value: T): void;
+    get(): T | undefined;
+    delete(): void;
+    has(): boolean;
+}
+declare class RowDetailCache<K = RowDetailCacheKey, T = RowDetailCacheEntry> implements RowDetailCacheStorage<K, T> {
+    private cacheStorage;
+    constructor(cache?: boolean | number);
+    add(key: K, value: T): void;
+    get(key: K): T | undefined;
+    delete(key: K): void;
+    has(key: K): boolean;
+}
+
+type BooleanCollectionStateKeys<KeyType> = true | KeyType[];
+type BooleanCollectionStateObject<KeyType> = {
+    positiveItems: BooleanCollectionStateKeys<KeyType>;
+    negativeItems: BooleanCollectionStateKeys<KeyType>;
+};
+declare abstract class BooleanCollectionState<StateObject, KeyType> {
+    protected positiveMap?: Map<KeyType, true>;
+    protected negativeMap?: Map<KeyType, true>;
+    protected allNegative: boolean;
+    protected allPositive: boolean;
+    private initialState;
+    constructor(state: BooleanCollectionStateObject<KeyType> | BooleanCollectionState<StateObject, KeyType>);
+    abstract getPositiveFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
+    abstract getNegativeFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
+    abstract getState(): StateObject;
+    protected getInitialState(): BooleanCollectionStateObject<KeyType>;
+    destroy(): void;
+    private update;
+    protected isDefaultNegativeSelection(): boolean;
+    protected isDefaultPositiveSelection(): boolean;
+    protected areAllNegative(): boolean;
+    protected areAllPositive(): boolean;
+    protected makeAllNegative(): void;
+    protected makeAllPositive(): void;
+    protected isItemPositive(key: KeyType): boolean;
+    protected isItemNegative(key: KeyType): boolean;
+    protected setItemValue(key: KeyType, shouldMakePositive: boolean): void;
+    protected makeItemNegative(key: KeyType): void;
+    protected makeItemPositive(key: KeyType): void;
+    protected toggleItem(key: KeyType): void;
+}
+
+declare class RowDetailState<KeyType = any> extends BooleanCollectionState<RowDetailStateObject<KeyType>, KeyType> {
+    constructor(state: RowDetailStateObject<KeyType> | RowDetailState<KeyType>);
+    getState(): RowDetailStateObject<KeyType>;
+    getPositiveFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
+    getNegativeFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
+    areAllCollapsed(): boolean;
+    areAllExpanded(): boolean;
+    collapseAll(): void;
+    expandAll(): void;
+    isRowDetailsExpanded: (key: KeyType) => boolean;
+    isRowDetailsCollapsed(key: KeyType): boolean;
+    setRowDetailsExpanded(key: KeyType, shouldExpand: boolean): void;
+    collapseRowDetails(key: KeyType): void;
+    expandRowDetails(key: KeyType): void;
+    toggleRowDetails(key: KeyType): void;
+}
+
+/**
+ * Framework-neutral DOM-related types shared across framework builds.
+ * They are intentionally minimal structural types so that both React
+ * synthetic events/refs and native DOM events (Vue, etc.) satisfy them.
+ */
+/**
+ * Neutral element ref callback — React's RefCallback and any framework's
+ * mount/unmount element callback are assignable to this shape.
+ */
+type ElementRefCallback = (el: HTMLElement | null) => void;
+/**
+ * Neutral mouse event contract for grid cell/row hover handling.
+ * Only the members the shared rendering logic actually reads.
+ * React.MouseEvent<HTMLElement> and native MouseEvent (with an HTMLElement
+ * currentTarget) both satisfy it.
+ */
+type GridMouseEvent = {
+    currentTarget: EventTarget & HTMLElement;
+};
+/**
+ * Neutral mutable ref holder — replaces React.RefObject/MutableRefObject
+ * in shared (framework-free) state types.
+ */
+type MutableRef<T> = {
+    current: T;
+};
+
+type TableRenderCellFnParam = {
+    domRef: ElementRefCallback;
+    rowIndex: number;
+    colIndex: number;
+    rowspan: number;
+    colspan: number;
+    hidden: boolean;
+    width: number;
+    height: number;
+    widthWithColspan: number;
+    heightWithRowspan: number;
+    rowFixed: FixedPosition;
+    colFixed: FixedPosition;
+    onMouseEnter: (event: GridMouseEvent) => void;
+    onMouseLeave: (event: GridMouseEvent) => void;
+};
+type TableRenderDetailRowFnParam = {
+    domRef: ElementRefCallback;
+    rowIndex: number;
+    hidden: boolean;
+    height: number;
+    rowFixed: FixedPosition;
+    onMouseEnter: (event: GridMouseEvent) => void;
+    onMouseLeave: (event: GridMouseEvent) => void;
+};
+type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
+type TableRenderDetailRowFn = (param: TableRenderDetailRowFnParam) => Renderable;
+type RenderRangeOptions = {
+    force?: boolean;
+    renderCell: TableRenderCellFn;
+    renderDetailRow?: TableRenderDetailRowFn;
+    onRender: (items: Renderable[]) => void;
+};
+type HorizontalLayoutColVisibilityOptions = {
+    horizontalLayoutPageIndex?: number;
+};
+
+interface GridCellInterface<T_ADDITIONAL_CELL_INFO = any> {
+    debugId: string;
+    update(content: Renderable, additionalInfo?: T_ADDITIONAL_CELL_INFO): void;
+    getElement(): HTMLElement | null;
+    getNode(): Renderable;
+    destroy(): void;
+    onMount(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
+    getAdditionalInfo(): T_ADDITIONAL_CELL_INFO | undefined;
+    isMounted(): boolean;
+    ref: ElementRefCallback;
+    setPendingAfterCommitWork(fn: (() => void) | null): void;
+    flushPendingAfterCommitWork(): void;
+}
+/**
+ * The framework-neutral contract for a pool of grid cells.
+ *
+ * A pool owns cell instances (attached ones render an x,y position in the
+ * grid; detached ones wait to be reused) but is not aware of cell positions —
+ * that's the GridCellManager's job. Each framework provides its own
+ * implementation (React: GridCellPoolForReact); the composition point that
+ * picks the implementation is createRenderer.
+ */
+interface GridCellPool<T_ADDITIONAL_CELL_INFO = any> {
+    poolSize: number;
+    attachCell(cell?: GridCellInterface<T_ADDITIONAL_CELL_INFO>): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    detachCell(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
+    getDetachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    getAttachedCells(): Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
+    getDetachedCells(): Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
+    getAllCells(): Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
+    onRemoveCell(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): VoidFunction;
+    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFunction;
+    reset(): void;
+    destroy(): void;
+    flushPendingAfterCommitWork(): void;
+}
+
+type CellPos = [number, number];
+
+declare class GridCellManager<T_ADDITIONAL_CELL_INFO> extends Logger {
+    private matrix;
+    private rowsWithCellsHistory;
+    private columnsWithCellsHistory;
+    private cellToMatrixPosition;
+    private pool;
+    debugId: string;
+    private offRemoveCell;
+    constructor(debugId: string, pool: GridCellPool<T_ADDITIONAL_CELL_INFO>);
+    private onRemoveCell;
+    set poolSize(cellCount: number);
+    get poolSize(): number;
+    getDetachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    private clearCellFromMatrix;
+    private addCellToMatrix;
+    private setCellPositionInMatrix;
+    renderNodeAtCell(node: Renderable, cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, cellPos: CellPos, additionalInfo?: T_ADDITIONAL_CELL_INFO): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    getCellPosition(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): CellPos | null;
+    getCellAt(cellPos: CellPos): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    /**
+     * This gets a cell for a given position.
+     * If there's already a cell currently attached at that position, it will be returned.
+     *
+     * Otherwise, we try to return the most optimal cell to use for that position.
+     * If the optimise parameter is set to 'row', we will try to return a detached cell
+     * that was last rendered in that row.
+     *
+     * If the optimise parameter is set to 'column', we will try to return a detached cell
+     * that was last rendered in that column.
+     *
+     * @param cellPos [rowIndex, colIndex]
+     * @param optimise 'row' | 'column'
+     */
+    getCellFor(cellPos: CellPos, optimise: 'row' | 'column'): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
+    isCellAttached(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
+    isCellAttachedAt(cellPos: CellPos): boolean;
+    getMatrix(): Renderable[][];
+    getAllCells(): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
+    getCellsForRow(rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
+    getOneAttachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    getRowsWithCells(): number[];
+    getColumnsWithCells(): number[];
+    isRowAttached(rowIndex: number): boolean;
+    isColumnAttached(colIndex: number): boolean;
+    detachRow(rowIndex: number): void;
+    detachCol(colIndex: number): void;
+    detachCell(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
+    detachCells(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>): void;
+    detachRowsStartingWith(rowIndex: number): void;
+    detachColsStartingWith(colIndex: number): void;
+    detachCellsStartingAt(cellPos: CellPos): void;
+    detachCellAt(cellPos: CellPos): boolean;
+    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFunction;
+    getCellsOutsideRenderRange: (range: TableRenderRange) => Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
+    getCellFromListForRow(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    getCellFromListForColumn(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, colIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
+    getCellCountInMatrix(): number;
+    flushPendingAfterCommitWork(): void;
+    destroy(): void;
+    reset(): void;
+    makeDetachedCellsEmpty(): void;
+    withDetachedCells(fn: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
+}
+
+/**
+ * This is only used for rendering Detail rows in a master-detail DataGrid
+ */
+interface ListRowInterface {
+    debugId: string;
+    update(content: Renderable): void;
+    getElement(): HTMLElement | null;
+    getNode(): Renderable;
+    destroy(): void;
+    onMount(callback: (row: ListRowInterface) => void): void;
+    isMounted(): boolean;
+    ref: ElementRefCallback;
+}
+/**
+ * The framework-neutral contract for a pool of list rows (used for
+ * master-detail rows). Same pooling model as GridCellPool; each framework
+ * provides its own implementation (React: ListRowPoolForReact).
+ */
+interface ListRowPool {
+    poolSize: number;
+    attachRow(row?: ListRowInterface): ListRowInterface;
+    detachRow(row: ListRowInterface): boolean;
+    getDetachedRow(): ListRowInterface;
+    getAttachedRows(): Set<ListRowInterface>;
+    getDetachedRows(): Set<ListRowInterface>;
+    getAllRows(): Set<ListRowInterface>;
+    onRemoveRow(callback: (row: ListRowInterface) => void): VoidFunction;
+    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFunction;
+    reset(): void;
+    destroy(): void;
+}
+
+declare class ListRowManager extends Logger {
+    private pool;
+    private indexToRow;
+    private rowToIndex;
+    debugId: string;
+    private offRemoveRow;
+    constructor(debugId: string, pool: ListRowPool);
+    private onRemoveRow;
+    set poolSize(rowCount: number);
+    get poolSize(): number;
+    getDetachedRow(): ListRowInterface;
+    /**
+     * This gets a row for a given position.
+     * If there's already a row currently attached at that position, it will be returned.
+     *
+     * Otherwise, we return another row.
+     * @param rowIndex
+     */
+    getRowFor(rowIndex: number): ListRowInterface;
+    private setRowIndexInList;
+    detachStartingWith(rowIndex: number): void;
+    getRowAt(rowPos: number): ListRowInterface | undefined;
+    getRowIndex(row: ListRowInterface): number | undefined;
+    isRowAttached(row: ListRowInterface): boolean;
+    isRowAttachedAt(rowIndex: number): boolean;
+    getList(): Renderable[];
+    getAttachedCount(): number;
+    forEachAttachedRow(fn: (row: ListRowInterface) => void): void;
+    getAttachedIndexes(): number[];
+    getAllRows(): ListRowInterface[];
+    detachRowAt(rowIndex: number): void;
+    detachRow(row: ListRowInterface): void;
+    renderNodeAtRow(node: Renderable, row: ListRowInterface, rowIndex: number): ListRowInterface;
+    makeDetachedRowsEmpty(): void;
+    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFunction;
+    withDetachedRows(fn: (row: ListRowInterface) => void): void;
+    destroy(): void;
+    reset(): void;
+}
+
+type GridCellAdditionalInfo = {
+    renderRowIndex: number;
+    renderColIndex: number;
+};
+/**
+ * The framework-specific pools the renderer works with.
+ * The composition point that builds these (per framework) is createRenderer.
+ */
+type GridRendererPools = {
+    cellPool: GridCellPool<GridCellAdditionalInfo>;
+    rowPool: ListRowPool;
 };
-type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotColumn: true;
-    pivotTotalColumn: boolean;
-    pivotAggregator: AggregationReducer<DataType, any>;
-    pivotAggregatorIndex: number;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex?: PivotBy<DataType, KeyType>;
-    pivotIndex: number;
-    pivotGroupKey: KeyType;
+declare class GridRenderer extends Logger {
+    protected brain: MatrixBrain;
+    debugId: string;
+    protected destroyed: boolean;
+    private scrolling;
+    cellHoverClassNames: string[];
+    cellDetachedClassNames: string[];
+    cellManager: GridCellManager<GridCellAdditionalInfo>;
+    protected rowManager: ListRowManager;
+    private lastEnteredRow;
+    private lastExitedRow;
+    private onDestroy;
+    private hoverRowUpdatesInProgress;
+    private infiniteNode;
+    private getInfiniteNode;
+    setDetailTransform: (element: HTMLElement, _rowIndex: number, { y, scrollTop, scrollLeft, }: {
+        y: number;
+        scrollTop?: boolean;
+        scrollLeft?: number;
+    }) => void;
+    setTransform: (element: HTMLElement, _rowIndex: number, colIndex: number, { x, y, scrollLeft, scrollTop, }: {
+        x: number;
+        y: number;
+        scrollLeft?: boolean;
+        scrollTop?: boolean;
+    }, zIndex: number | "auto" | undefined | null) => void;
+    constructor(brain: MatrixBrain, debugId: string | undefined, pools: GridRendererPools);
+    private onCellAttached;
+    private onCellDetached;
+    private onRowAttached;
+    private onRowDetached;
+    getFullyVisibleRowsRange: () => {
+        start: number;
+        end: number;
+    } | null;
+    getScrollPositionForScrollRowIntoView: (rowIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+        colIndex?: number;
+    }) => ScrollPosition | null;
+    getScrollPositionForScrollColumnIntoView: (colIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    } & HorizontalLayoutColVisibilityOptions) => ScrollPosition | null;
+    getScrollPositionForScrollCellIntoView: (rowIndex: number, colIndex: number, config?: {
+        rowScrollAdjustPosition?: ScrollAdjustPosition;
+        colScrollAdjustPosition?: ScrollAdjustPosition;
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offsetTop: number;
+        offsetLeft: number;
+    }) => ScrollPosition | null;
+    isRowFullyVisible: (rowIndex: number, offsetMargin?: number) => boolean;
+    isRowVisible: (rowIndex: number, offsetMargin?: number) => boolean;
+    isRowRendered: (rowIndex: number) => boolean;
+    isCellVisible: (rowIndex: number, colIndex: number) => boolean;
+    isCellFullyVisible: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isColumnFullyVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isColumnVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isCellRendered: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    isColumnRendered: (colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
+    getExtraSpanCellsForRange: (range: TableRenderRange) => [number, number][];
+    isCellRenderedAndMappedCorrectly(row: number, col: number): {
+        rendered: boolean;
+        mapped: boolean;
+    };
+    renderRange(range: TableRenderRange, { renderCell, renderDetailRow, force, onRender }: RenderRangeOptions): Renderable[];
+    getFixedRanges: (currentRenderRange: TableRenderRange) => TableRenderRange[];
+    protected isCellFixed: (rowIndex: number, colIndex: number) => {
+        row: FixedPosition;
+        col: FixedPosition;
+    };
+    protected isCellCovered: (rowIndex: number, colIndex: number) => false | number[];
+    private renderDetailRowAtElement;
+    protected getCellRealCoordinates(rowIndex: number, colIndex: number): {
+        rowIndex: number;
+        colIndex: number;
+    };
+    protected onMouseEnterNotBound: (event: GridMouseEvent) => void;
+    protected onMouseLeaveNotBound: (event: GridMouseEvent) => void;
+    private getMatrixRowIndexFromElement;
+    protected renderCellAt(rowIndex: number, colIndex: number, cell: GridCellInterface, renderCell: TableRenderCellFn): void;
+    protected onMouseEnter: (rowIndex: number) => void;
+    private addHoverClass;
+    protected onMouseLeave: (rowIndex: number) => void;
+    private removeHoverClass;
+    protected updateHoverClassNamesForRow: (rowIndex: number) => void;
+    protected updateElementPosition: (cell: GridCellInterface<{
+        renderRowIndex: number;
+        renderColIndex: number;
+    }>, options?: {
+        hidden: boolean;
+        rowspan: number;
+        colspan: number;
+    }) => void;
+    private updateDetailElementPosition;
+    private onScrollStart;
+    private onScrollStop;
+    adjustFixedElementsOnScroll: (scrollPosition?: ScrollPosition) => void;
+    flushPendingAfterCommitWork: () => void;
+    destroy: () => void;
+    reset(): void;
+}
+
+type CellPositionByIndex = {
+    rowIndex: number;
+    colIndex: number;
 };
-type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
-type InfiniteTableComputedColumnBase<T> = {
-    computedFilterType: string;
-    computedSortType: string | string[];
-    computedDataType: string;
-    computedWidth: number;
-    computedFlex: number | null;
-    computedMinWidth: number;
-    computedMaxWidth: number;
-    computedOffset: number;
-    computedPinningOffset: number;
-    computedAbsoluteOffset: number;
-    computedSortInfo: DataSourceSingleSortInfo<T> | null;
-    computedSorted: boolean;
-    computedSortedAsc: boolean;
-    computedSortedDesc: boolean;
-    computedSortIndex: number;
-    computedVisible: boolean;
-    computedVisibleIndex: number;
-    computedVisibleIndexInCategory: number;
-    computedMultiSort: boolean;
-    computedFiltered: boolean;
-    computedFilterable: boolean;
-    computedGroupedBy: boolean;
-    computedGroupedByIndex: number | undefined;
-    computedGroupable: boolean;
-    computedFilterValue: DataSourceFilterValueItem<T> | null;
-    computedPinned: InfiniteTableColumnPinnedValues;
-    computedDraggable: boolean;
-    computedResizable: boolean;
-    computedFirstInCategory: boolean;
-    computedLastInCategory: boolean;
-    computedFirst: boolean;
-    computedLast: boolean;
-    computedEditable: NonUndefined<InfiniteTableColumn<T>['defaultEditable']>;
-    computedSortable: NonUndefined<InfiniteTableColumn<T>['defaultSortable']>;
-    colType: InfiniteTableColumnType<T>;
-    id: string;
+type MultiSelectRangeOptions = {
+    horizontalLayout: false;
+} | {
+    horizontalLayout: true;
+    rowsPerPage: number;
+    columnsPerSet: number;
 };
-type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
-type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
+
+type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
+interface SubscriptionCallback<T> {
+    (node: T, callback?: () => void): void;
+    get: () => T | null;
+    destroy: VoidFn;
+    onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
+    getListenersCount: () => number;
+}
+
+declare class ScrollListener {
+    private scrollPosition;
+    private onScrollFns;
+    getScrollPosition: () => ScrollPosition;
+    onScroll: (fn: OnScrollFn) => () => void;
+    setScrollPosition: (scrollPosition: ScrollPosition) => void;
+    private notifyScrollChange;
+    destroy: () => void;
+}
 
 declare const DS_ERROR_CODES: Record<"DS001", DebugWarningPayload>;
 declare const INFINITE_ERROR_CODES: Record<"CSS001_CSS", DebugWarningPayload>;
@@ -1846,6 +2045,15 @@ type DevToolsHostPageMessagePayload = {
     devToolsDetected: InfiniteTableState<any>['devToolsDetected'];
     debugTimings: Record<DebugTimingKey, number>;
     debugWarnings: Record<ErrorCodeKey, DebugWarningPayload>;
+    /**
+     * Computed values for all public `--infinite-*` theme CSS variables,
+     * read from the table root DOM node.
+     */
+    themeVars: Record<string, string>;
+    /**
+     * CSS variable overrides currently applied by the devtools theme builder.
+     */
+    themeVarOverrides: Record<string, string>;
 };
 type DevToolsHostPageMessageType = 'update' | 'unmount' | 'log';
 type DevToolsHostPageLogMessage = {
@@ -2317,6 +2525,11 @@ type InfiniteTableAction = {
     payload?: any;
 };
 
+/**
+ * Framework-neutral row-height computation (including row-detail heights),
+ * extracted from useComputedRowHeight.ts so the Vue root can share it.
+ */
+
 declare class RowSizeCache {
     rowHeight: Map<number, number>;
     rowDetailHeight: Map<number, number>;
@@ -2540,7 +2753,101 @@ type NestedMultiSortOptions<T> = {
     inplace?: boolean;
     marker?: PerfMarker;
 };
-declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];
+declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];
+
+type RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
+};
+
+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, originalData: DataType, metadata: any) => void;
+    insert: (primaryKey: PrimaryKeyType, data: DataType, position: "before" | "after", metadata: any) => void;
+    insertNodePath: (nodePath: NodePath$1, data: DataType, position: "before" | "after", metadata: any) => void;
+    update: (primaryKey: PrimaryKeyType, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
+    updateNodePath: (nodePath: NodePath$1, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
+    updateChildren: (nodePath: NodePath$1, 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) => void;
+    getMutationsForPrimaryKey: (primaryKey: PrimaryKeyType) => DataSourceMutation<DataType>[] | undefined;
+    getMutationsForNodePath: (nodePath: NodePath$1) => DataSourceMutation<DataType>[] | undefined;
+    getMutationsCount: () => number;
+    getMutations: () => Map<PrimaryKeyType, DataSourceMutation<DataType>[]>;
+    getTreeMutations: () => DeepMap<NodePath$1, DataSourceMutation<DataType>[]>;
+    getMutationsArray: () => DataSourceMutation<DataType>[];
+    getTreeMutationsArray: () => DataSourceMutation<DataType>[];
+}
 
 type ForceOptions = {
     force?: boolean;
@@ -2813,13 +3120,13 @@ interface DataSourceSetupState<T> {
     debugTimings: Map<DebugTimingKey, number>;
     debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
     indexer: Indexer<T, any>;
-    getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-    __apiRef: React$1.RefObject<DataSourceApi<T> | null>;
-    lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+    getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+    __apiRef: MutableRef<DataSourceApi<T> | null>;
+    lastSelectionUpdatedNodePathRef: MutableRef<{
         nodePath: NodePath$1;
         selected: boolean;
     } | null>;
-    lastExpandStateInfoRef: React$1.RefObject<{
+    lastExpandStateInfoRef: MutableRef<{
         state: 'collapsed' | 'expanded';
         nodePath: NodePath$1 | null;
     }>;
@@ -2834,7 +3141,7 @@ interface DataSourceSetupState<T> {
      */
     rowsPerPage: number | null;
     totalLeafNodesCount: number;
-    destroyedRef: React$1.MutableRefObject<boolean>;
+    destroyedRef: MutableRef<boolean>;
     idToIndexMap: Map<any, number>;
     idToPathMap: Map<any, NodePath$1>;
     pathToIndexMap: DeepMap<any, number>;
@@ -3029,7 +3336,7 @@ type TreeExpandStateValue = TreeExpandState | TreeExpandStateObject<any>;
 type DataSourceProps<T> = {
     nodesKey?: never;
     debugId?: string;
-    children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
+    children?: Renderable | ((contextData: DataSourceState<T>) => Renderable);
     primaryKey: keyof T | ((data: T) => string);
     /**
      * @deprecated for now
@@ -3168,8 +3475,8 @@ type DataSourceFilterType<T> = {
     defaultOperator: string;
     valueGetter?: DataSourceFilterValueItemValueGetter<T>;
     components?: {
-        FilterEditor?: () => React$1.JSX.Element | null;
-        FilterOperatorSwitch?: () => React$1.JSX.Element | null;
+        FilterEditor?: () => Renderable;
+        FilterOperatorSwitch?: () => Renderable;
     };
     operators: DataSourceFilterOperator<T>[];
 };
@@ -3177,8 +3484,8 @@ type DataSourceFilterOperator<T> = {
     name: string;
     label?: string;
     components?: {
-        FilterEditor?: () => React$1.JSX.Element | null;
-        Icon?: (props: any) => React$1.JSX.Element | null;
+        FilterEditor?: () => Renderable;
+        Icon?: (props: any) => Renderable;
     };
     fn: DataSourceFilterOperatorFunction<T>;
     defaultFilterValue?: any;
@@ -3252,201 +3559,9 @@ interface DataSourceAction<T> {
     payload: T;
 }
 
-type InfiniteTableBaseCellProps<T> = {
-    column: InfiniteTableComputedColumn<T>;
-    align?: InfiniteTableColumnAlignValues;
-    horizontalLayoutPageIndex: number | null;
-    rowId?: any;
-    renderChildren: React.ReactNode | (() => Renderable);
-    width: number;
-    cssEllipsis?: boolean;
-    contentStyle?: CSSProperties;
-    contentClassName?: string;
-    virtualized?: boolean;
-    skipColumnShifting?: boolean;
-    beforeChildren?: Renderable;
-    afterChildren?: Renderable;
-    cssPosition?: CSSProperties['position'];
-    domRef?: React.RefCallback<HTMLElement>;
-    repaintId?: number | string;
-};
-type InfiniteTableCellProps<T> = ({
-    cellType: 'header';
-} & InfiniteTableBaseCellProps<T>) | ({
-    cellType: 'body';
-} & InfiniteTableBaseCellProps<T>);
-
-declare function useInfiniteHeaderCell<T>(): {
-    dragging: boolean;
-    column: InfiniteTableComputedColumn<T>;
-    columnsMap: Map<string, InfiniteTableComputedColumn<T>>;
-    columnSortInfo: DataSourceSingleSortInfo<T> | null;
-    columnFilterValue: DataSourceFilterValueItem<T> | null;
-    selectionMode: DataSourcePropSelectionMode;
-    horizontalLayoutPageIndex: null | number;
-    allRowsSelected: boolean;
-    someRowsSelected: boolean;
-    filtered: boolean;
-    api: InfiniteTableApi<T>;
-    dataSourceApi: DataSourceApi<T>;
-    columnApi: InfiniteTableColumnApi<T>;
-    renderBag: {
-        all?: Renderable;
-        header: string | number | Renderable;
-        sortIcon?: Renderable;
-        menuIcon?: Renderable;
-        menuIconProps?: MenuIconProps;
-        filterIcon?: Renderable;
-        filterEditor?: Renderable;
-        selectionCheckBox?: Renderable;
-    };
-} & {
-    domRef: InfiniteTableCellProps<DATA_TYPE>["domRef"];
-    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
-    renderLocation: "column-header";
-} & {
-    domRef: InfiniteTableCellProps<DATA_TYPE_1>["domRef"];
-    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
-    renderLocation: "column-header";
-};
-
-declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
-declare function useInfiniteColumnEditor<T>(): InfiniteColumnEditorContextType<T>;
-
-declare function useInfiniteColumnFilterEditor<T>(): {
-    api: InfiniteTableApi<T>;
-    column: InfiniteTableComputedColumn<T>;
-    columnFilterValue: DataSourceFilterValueItem<any> | null;
-    columnApi: InfiniteTableColumnApi<T>;
-    operatorName: string | undefined;
-    operator: DataSourceFilterOperator<any> | undefined;
-    value: any;
-    disabled: boolean | undefined;
-    filterType: DataSourceFilterType<any>;
-    filterTypes: DataSourcePropFilterTypes<any>;
-    filterTypeKey: string;
-    filtered: boolean;
-    setValue: (filterValue: any) => void;
-    clearValue: () => void;
-    removeColumnFilter: () => void;
-    ariaLabel: string;
-    className: string;
-};
-
-type HotKeyEventDescriptor = {
-    key: KeyboardEvent['key'];
-    metaKey: KeyboardEvent['metaKey'];
-    altKey: KeyboardEvent['altKey'];
-    ctrlKey: KeyboardEvent['ctrlKey'];
-    shiftKey: KeyboardEvent['shiftKey'];
-};
-declare function eventMatchesKeyboardShortcut(event: HotKeyEventDescriptor, keyDescriptors: string | string[]): boolean;
-
-declare function HScrollSyncContent(props: HTMLAttributes<HTMLDivElement> & {
-    width?: 'viewport' | 'column';
-    maxWidth?: 'viewport' | 'column';
-    minWidth?: 'viewport' | 'column';
-    scrollable?: boolean;
-}): React$1.JSX.Element;
-
-declare function useGridScroll(onScroll: (scrollPosition: ScrollPosition) => void, deps: any[]): void;
-
-declare function useVisibleColumnSizes<T>(): {
-    id: string;
-    width: number;
-    cssVarForWidth: string;
-    offset: number;
-    cssVarForOffset: string;
-    pinned: InfiniteTableColumnPinnedValues;
-}[];
-
-declare function useInfinitePortalContainer(): HTMLDivElement | null;
-
-declare function HostDefault(props: {
-    active: boolean;
-    orientation: 'horizontal' | 'vertical';
-    rejectDrop: boolean;
-    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
-}): React$1.JSX.Element;
-declare function PlaceholderDefault<T = any>(props: {
-    draggingInProgress: boolean;
-    active: boolean;
-    groupBy: DataSourcePropGroupBy<T>;
-}): React$1.ReactNode;
-declare function GroupingToolbarItemDefault<T = any>(props: {
-    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
-    column: InfiniteTableComputedColumn<T> | undefined;
-    field: string | number | undefined;
-    active: boolean;
-    label: React$1.ReactNode;
-    onClear: () => void;
-}): React$1.JSX.Element;
-
-type GroupingToolbarProps = {
-    orientation?: 'horizontal' | 'vertical';
-    placeholder?: <T = any>(params: {
-        draggingInProgress: boolean;
-        active: boolean;
-        groupBy: DataSourcePropGroupBy<T>;
-    }) => React$1.ReactNode;
-    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
-    components?: {
-        Host?: typeof HostDefault;
-        Placeholder?: typeof PlaceholderDefault;
-        ToolbarItem?: typeof GroupingToolbarItemDefault;
-    };
-};
-declare function GroupingToolbar<T = any>(props: GroupingToolbarProps): React$1.JSX.Element;
-
-type InfiniteTableHeaderProps<_T> = {
-    allowColumnHideWhileDragging?: boolean;
-};
-
-type InfiniteTableBodyProps<_T> = {
-    rowHoverClassName?: string | string[];
-};
-
-declare function InfiniteTableBody<T>(props: InfiniteTableBodyProps<T>): React$1.JSX.Element;
-declare namespace InfiniteTableBody {
-    var rowHoverClassName: string[];
-}
-
-declare function useInfiniteTableApi<T>(): InfiniteTableApi<T>;
-
-declare function useInfiniteColumnApi<T = unknown>(columnId: string): InfiniteTableColumnApi<T> | null;
-
-declare const InfiniteTableClassName: string;
-declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => React$1.JSX.Element)>;
-type InfiniteTableComponent = {
-    <T>(props: InfiniteTableProps<T>): React$1.JSX.Element;
-    licenseKey?: string;
-    Header: <T = any>(props: InfiniteTableHeaderProps<T>) => React$1.JSX.Element | null;
-    Body: typeof InfiniteTableBody;
-    Footer: () => React$1.JSX.Element | null;
-    HScrollSyncContent: typeof HScrollSyncContent;
-    GroupingToolbar: typeof GroupingToolbar;
-};
-declare const InfiniteTable: InfiniteTableComponent;
+declare const withSelectedLeafNodesOnly: (callback: (treeSelectionObject: TreeSelectionStateObject) => void) => DataSourcePropOnTreeSelectionChange_MultiNode;
 
-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 function TreeGrid<T>(props: TreeGridProps<T>): React$1.JSX.Element;
 
 declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
 
@@ -3495,13 +3610,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -3513,7 +3628,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -3637,13 +3752,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -3655,7 +3770,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -3779,13 +3894,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -3797,7 +3912,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -3922,13 +4037,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -3940,7 +4055,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4064,13 +4179,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4082,7 +4197,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4206,13 +4321,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4224,7 +4339,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4349,13 +4464,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4367,7 +4482,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4491,13 +4606,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4509,7 +4624,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4633,13 +4748,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4651,7 +4766,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4776,13 +4891,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4794,7 +4909,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -4918,13 +5033,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -4936,7 +5051,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -5060,13 +5175,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -5078,7 +5193,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -5203,13 +5318,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -5221,7 +5336,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -5345,13 +5460,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -5363,7 +5478,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -5487,13 +5602,13 @@ declare const useManagedDataSource: (props: object) => {
             debugTimings: Map<DebugTimingKey, number>;
             debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
             indexer: Indexer<unknown, any>;
-            getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-            __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-            lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+            getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: MutableRef<{
                 nodePath: NodePath$1;
                 selected: boolean;
             } | null>;
-            lastExpandStateInfoRef: React$1.RefObject<{
+            lastExpandStateInfoRef: MutableRef<{
                 state: "collapsed" | "expanded";
                 nodePath: NodePath$1 | null;
             }>;
@@ -5505,7 +5620,7 @@ declare const useManagedDataSource: (props: object) => {
             repeatWrappedGroupRows: never;
             rowsPerPage: never;
             totalLeafNodesCount: number;
-            destroyedRef: React$1.MutableRefObject<boolean>;
+            destroyedRef: MutableRef<boolean>;
             idToIndexMap: Map<any, number>;
             idToPathMap: Map<any, NodePath$1>;
             pathToIndexMap: DeepMap<any, number>;
@@ -5631,13 +5746,13 @@ declare const useManagedDataSource: (props: object) => {
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
-        getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-        __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-        lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+        getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: MutableRef<{
             nodePath: NodePath$1;
             selected: boolean;
         } | null>;
-        lastExpandStateInfoRef: React$1.RefObject<{
+        lastExpandStateInfoRef: MutableRef<{
             state: "collapsed" | "expanded";
             nodePath: NodePath$1 | null;
         }>;
@@ -5649,7 +5764,7 @@ declare const useManagedDataSource: (props: object) => {
         repeatWrappedGroupRows: never;
         rowsPerPage: never;
         totalLeafNodesCount: number;
-        destroyedRef: React$1.MutableRefObject<boolean>;
+        destroyedRef: MutableRef<boolean>;
         idToIndexMap: Map<any, number>;
         idToPathMap: Map<any, NodePath$1>;
         pathToIndexMap: DeepMap<any, number>;
@@ -5773,13 +5888,13 @@ declare const useManagedDataSource: (props: object) => {
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
-        getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-        __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-        lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+        getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: MutableRef<{
             nodePath: NodePath$1;
             selected: boolean;
         } | null>;
-        lastExpandStateInfoRef: React$1.RefObject<{
+        lastExpandStateInfoRef: MutableRef<{
             state: "collapsed" | "expanded";
             nodePath: NodePath$1 | null;
         }>;
@@ -5791,7 +5906,7 @@ declare const useManagedDataSource: (props: object) => {
         repeatWrappedGroupRows: never;
         rowsPerPage: never;
         totalLeafNodesCount: number;
-        destroyedRef: React$1.MutableRefObject<boolean>;
+        destroyedRef: MutableRef<boolean>;
         idToIndexMap: Map<any, number>;
         idToPathMap: Map<any, NodePath$1>;
         pathToIndexMap: DeepMap<any, number>;
@@ -5915,13 +6030,13 @@ declare const useManagedDataSource: (props: object) => {
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
-        getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-        __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-        lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+        getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: MutableRef<{
             nodePath: NodePath$1;
             selected: boolean;
         } | null>;
-        lastExpandStateInfoRef: React$1.RefObject<{
+        lastExpandStateInfoRef: MutableRef<{
             state: "collapsed" | "expanded";
             nodePath: NodePath$1 | null;
         }>;
@@ -5933,7 +6048,7 @@ declare const useManagedDataSource: (props: object) => {
         repeatWrappedGroupRows: never;
         rowsPerPage: never;
         totalLeafNodesCount: number;
-        destroyedRef: React$1.MutableRefObject<boolean>;
+        destroyedRef: MutableRef<boolean>;
         idToIndexMap: Map<any, number>;
         idToPathMap: Map<any, NodePath$1>;
         pathToIndexMap: DeepMap<any, number>;
@@ -6057,13 +6172,13 @@ declare const useManagedDataSource: (props: object) => {
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
-        getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-        __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-        lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+        getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: MutableRef<{
             nodePath: NodePath$1;
             selected: boolean;
         } | null>;
-        lastExpandStateInfoRef: React$1.RefObject<{
+        lastExpandStateInfoRef: MutableRef<{
             state: "collapsed" | "expanded";
             nodePath: NodePath$1 | null;
         }>;
@@ -6075,7 +6190,7 @@ declare const useManagedDataSource: (props: object) => {
         repeatWrappedGroupRows: never;
         rowsPerPage: never;
         totalLeafNodesCount: number;
-        destroyedRef: React$1.MutableRefObject<boolean>;
+        destroyedRef: MutableRef<boolean>;
         idToIndexMap: Map<any, number>;
         idToPathMap: Map<any, NodePath$1>;
         pathToIndexMap: DeepMap<any, number>;
@@ -6199,13 +6314,13 @@ declare const useManagedDataSource: (props: object) => {
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
-        getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-        __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-        lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+        getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: MutableRef<{
             nodePath: NodePath$1;
             selected: boolean;
         } | null>;
-        lastExpandStateInfoRef: React$1.RefObject<{
+        lastExpandStateInfoRef: MutableRef<{
             state: "collapsed" | "expanded";
             nodePath: NodePath$1 | null;
         }>;
@@ -6217,7 +6332,7 @@ declare const useManagedDataSource: (props: object) => {
         repeatWrappedGroupRows: never;
         rowsPerPage: never;
         totalLeafNodesCount: number;
-        destroyedRef: React$1.MutableRefObject<boolean>;
+        destroyedRef: MutableRef<boolean>;
         idToIndexMap: Map<any, number>;
         idToPathMap: Map<any, NodePath$1>;
         pathToIndexMap: DeepMap<any, number>;
@@ -6341,13 +6456,13 @@ declare const useManagedDataSource: (props: object) => {
         debugTimings: Map<DebugTimingKey, number>;
         debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
         indexer: Indexer<unknown, any>;
-        getDataSourceMasterContextRef: React$1.RefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
-        __apiRef: React$1.RefObject<DataSourceApi<unknown> | null>;
-        lastSelectionUpdatedNodePathRef: React$1.RefObject<{
+        getDataSourceMasterContextRef: MutableRef<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: MutableRef<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: MutableRef<{
             nodePath: NodePath$1;
             selected: boolean;
         } | null>;
-        lastExpandStateInfoRef: React$1.RefObject<{
+        lastExpandStateInfoRef: MutableRef<{
             state: "collapsed" | "expanded";
             nodePath: NodePath$1 | null;
         }>;
@@ -6359,7 +6474,7 @@ declare const useManagedDataSource: (props: object) => {
         repeatWrappedGroupRows: never;
         rowsPerPage: never;
         totalLeafNodesCount: number;
-        destroyedRef: React$1.MutableRefObject<boolean>;
+        destroyedRef: MutableRef<boolean>;
         idToIndexMap: Map<any, number>;
         idToPathMap: Map<any, NodePath$1>;
         pathToIndexMap: DeepMap<any, number>;
@@ -6971,13 +7086,20 @@ type AlignPositionOptions = {
     alignTarget: Alignable;
 };
 
+type ElementContainerGetter = (() => HTMLElement | string | Promise<HTMLElement | string>) | string | HTMLElement | Promise<HTMLElement | string>;
+type AdvancedAlignable = Alignable | ElementContainerGetter;
+type OverlayShowParams = {
+    id?: string | number;
+    constrainTo?: AdvancedAlignable | boolean;
+    alignPosition: AlignPositionOptions['alignPosition'];
+    alignTo: AdvancedAlignable | PointCoords;
+};
+declare function alignNode(node: HTMLDivElement, params: OverlayShowParams): Promise<void>;
+
 type OverlayParams = {
     portalContainer?: ElementContainerGetter | null | false;
     constrainTo?: OverlayShowParams['constrainTo'];
 };
-type ElementContainerGetter = (() => HTMLElement | string | Promise<HTMLElement | string>) | string | HTMLElement | Promise<HTMLElement | string>;
-type AdvancedAlignable = Alignable | ElementContainerGetter;
-declare function alignNode(node: HTMLDivElement, params: OverlayShowParams): Promise<void>;
 /**
  * If portal container is given, it will create a React portal from that element
  * otherwise it will simply render another node as portal
@@ -6985,12 +7107,6 @@ declare function alignNode(node: HTMLDivElement, params: OverlayShowParams): Pro
  * @param portalContainer
  */
 declare function useOverlayPortal(content: ReactNode, portalContainer?: ElementContainerGetter | null | false): string | number | bigint | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
-type OverlayShowParams = {
-    id?: string | number;
-    constrainTo?: AdvancedAlignable | boolean;
-    alignPosition: AlignPositionOptions['alignPosition'];
-    alignTo: AdvancedAlignable | PointCoords;
-};
 type UpdateOverlayContentFn = (content: ReactNode | (() => ReactNode), options?: {
     skipRealign?: boolean;
 }) => void;