@infinite-table/infinite-react 5.1.0-canary.0 → 6.0.0

package/index.d.ts

@@ -88,6 +88,7 @@ declare class DeepMap<KeyType, ValueType> {
     constructor(initial?: [KeyType[], ValueType][]);
     fill(initial?: [KeyType[], ValueType][]): void;
     getValuesStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): ValueType[];
+    getEntriesStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): [KeyType[], ValueType][];
     getKeysStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): KeyType[][];
     private getStartingWith;
     private getMapAt;
@@ -234,6 +235,8 @@ declare type ShouldUpdateRenderCountOptions = {
 };
 declare class MatrixBrain extends Logger implements IBrain {
     private scrolling;
+    protected RENDER_COUNT_SAFETY_MARGIN_START: number;
+    protected RENDER_COUNT_SAFETY_MARGIN_END: number;
     protected availableWidth: MatrixBrainOptions['width'];
     protected availableRenderWidth: number;
     isHorizontalLayoutBrain: boolean;
@@ -266,6 +269,8 @@ declare class MatrixBrain extends Logger implements IBrain {
     private horizontalTotalSize;
     private horizontalRenderCount?;
     private verticalRenderCount?;
+    private horizontalExtendRangeBy;
+    private verticalExtendRangeBy;
     protected horizontalRenderRange: RenderRangeType;
     protected verticalRenderRange: RenderRangeType;
     protected extraSpanCells: [number, number][];
@@ -315,8 +320,9 @@ declare class MatrixBrain extends Logger implements IBrain {
      * @param options.right - if true, extends the right side with the amount of current visible columns, otherwise with the specified number
      */
     extendRenderRange(options: {
-        left?: number | boolean;
-        right?: number | boolean;
+        start?: number | boolean;
+        end?: number | boolean;
+        direction: 'horizontal' | 'vertical';
     }): () => void;
     updateRenderCount(which?: WhichDirection): void;
     protected doUpdateRenderCount(which?: WhichDirection): void;
@@ -327,11 +333,11 @@ declare class MatrixBrain extends Logger implements IBrain {
     private notifyScrollStop;
     setScrollPosition(scrollPosition: ScrollPosition, callback?: (scrollPos: ScrollPosition) => void): void;
     protected notifyAvailableSizeChange: () => void;
-    protected notifyRenderRangeChange(): void;
-    protected notifyVerticalRenderRangeChange: () => void;
-    protected notifyHorizontalRenderRangeChange: () => void;
+    protected notifyRenderRangeChange(immediate?: boolean): void;
+    protected notifyVerticalRenderRangeChange: (immediate?: boolean) => void;
+    protected notifyHorizontalRenderRangeChange: (immediate?: boolean) => void;
     private notifyScrollChange;
-    private computeDirectionalRenderCount;
+    protected computeDirectionalRenderCount(direction: 'horizontal' | 'vertical', itemSize: number | ItemSizeFunction, count: number, theRenderSize: Size): number;
     getFixedSize(direction: 'horizontal' | 'vertical'): number;
     getFixedStartSize(direction: 'horizontal' | 'vertical'): number;
     getFixedEndSize(direction: 'horizontal' | 'vertical'): number;
@@ -378,7 +384,7 @@ declare class MatrixBrain extends Logger implements IBrain {
     setRenderCount: ({ horizontal, vertical, }: {
         horizontal: number | undefined;
         vertical: number | undefined;
-    }, force?: boolean | undefined) => void;
+    }) => void;
     private notifyRenderCountChange;
     updateFixedCells: (config: {
         fixedColsStart?: number;
@@ -581,6 +587,7 @@ declare function MenuIcon(props: MenuIconProps): React$1.JSX.Element;
 declare type NonUndefined<T> = T extends undefined ? never : T;
 
 declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
+declare type InfiniteTableToggleTreeNodeFn = (nodePath: any[]) => void;
 declare type InfiniteTableToggleRowDetailsFn = (id: any) => void;
 declare type InfiniteTableSelectRowFn = (id: any) => void;
 declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
@@ -595,6 +602,7 @@ declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableC
     someRowsSelected: boolean;
     filtered: boolean;
     api: InfiniteTableApi<DATA_TYPE>;
+    dataSourceApi: DataSourceApi<DATA_TYPE>;
     columnApi: InfiniteTableColumnApi<DATA_TYPE>;
     renderBag: {
         all?: Renderable;
@@ -603,10 +611,12 @@ declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableC
         menuIcon?: Renderable;
         menuIconProps?: MenuIconProps;
         filterIcon?: Renderable;
+        filterEditor?: Renderable;
         selectionCheckBox?: Renderable;
     };
 } & ({
     domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    htmlElementRef: React__default.MutableRefObject<HTMLElement | null>;
     insideColumnMenu: false;
 } | {
     insideColumnMenu: true;
@@ -614,6 +624,7 @@ declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableC
 declare type InfiniteTableColumnRenderBag = {
     value: string | number | Renderable;
     groupIcon?: Renderable;
+    treeIcon?: Renderable;
     rowDetailsIcon?: Renderable;
     all?: Renderable;
     selectionCheckBox?: Renderable;
@@ -630,13 +641,19 @@ declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTa
     rowIndex: number;
     rowActive: boolean;
     api: InfiniteTableApi<DATA_TYPE>;
+    dataSourceApi: DataSourceApi<DATA_TYPE>;
     editError?: Error;
     column: COL_TYPE;
     columnsMap: Map<string, COL_TYPE>;
     fieldsToColumn: Map<keyof DATA_TYPE, COL_TYPE>;
     groupByColumn?: InfiniteTableComputedColumn<DATA_TYPE>;
     toggleCurrentGroupRow: () => void;
+    toggleCurrentTreeNode: () => void;
+    expandTreeNode: InfiniteTableToggleTreeNodeFn;
+    collapseTreeNode: InfiniteTableToggleTreeNodeFn;
     toggleGroupRow: InfiniteTableToggleGroupRowFn;
+    toggleTreeNode: InfiniteTableToggleTreeNodeFn;
+    toggleCurrentTreeNodeSelection: () => void;
     toggleCurrentGroupRowSelection: () => void;
     toggleCurrentRowSelection: () => void;
     toggleCurrentRowDetails: () => void;
@@ -653,6 +670,9 @@ declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTa
     deselectCell: () => void;
     toggleRowSelection: InfiniteTableSelectRowFn;
     toggleGroupRowSelection: InfiniteTableToggleGroupRowFn;
+    toggleTreeNodeSelection: InfiniteTableToggleTreeNodeFn;
+    selectTreeNode: InfiniteTableToggleTreeNodeFn;
+    deselectTreeNode: InfiniteTableToggleTreeNodeFn;
     selectionMode: DataSourcePropSelectionMode | undefined;
     rootGroupBy: DataSourceState<DATA_TYPE>['groupBy'];
     pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
@@ -669,6 +689,15 @@ declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTable
 declare type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
     isGroupRow: true;
 }) => Renderable | null;
+declare type InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
+    isTreeNode: true;
+    isParentNode: true;
+}) => Renderable | null;
+declare type InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
+    isTreeNode: true;
+    isParentNode: false;
+}) => Renderable | null;
+declare type InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, EXTRA_NODE_PARAMS = Partial<InfiniteTableRowInfoDataDiscriminator_ParentNode<DATA_TYPE> | InfiniteTableRowInfoDataDiscriminator_LeafNode<DATA_TYPE>>, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & EXTRA_NODE_PARAMS) => Renderable | null;
 declare type InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
     isGroupRow: false;
 }) => Renderable | null;
@@ -791,6 +820,22 @@ declare type InfiniteTableColumn<DATA_TYPE> = {
     maxWidth?: number;
     renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
     renderRowDetailIcon?: boolean | InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderTreeIcon?: boolean | InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, {
+        isTreeNode: true;
+        isParentNode: boolean;
+        isGroupRow: false;
+        nodeExpanded: boolean;
+    }>;
+    renderTreeIconForParentNode?: InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, {
+        isTreeNode: true;
+        isGroupRow: true;
+        isParentNode: true;
+    }>;
+    renderTreeIconForLeafNode?: InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, {
+        isTreeNode: true;
+        isGroupRow: false;
+        isLeafNode: true;
+    }>;
     renderSortIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
     renderFilterIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
     renderSelectionCheckBox?: boolean | InfiniteTableColumnOrHeaderRenderFunction<DATA_TYPE>;
@@ -931,6 +976,13 @@ declare type CellPositionByIndex = {
     rowIndex: number;
     colIndex: number;
 };
+declare type MultiSelectRangeOptions = {
+    horizontalLayout: false;
+} | {
+    horizontalLayout: true;
+    rowsPerPage: number;
+    columnsPerSet: number;
+};
 
 declare type MultiCellSelectorOptions = {
     getPrimaryKeyByIndex: (rowIndex: number) => string | number;
@@ -955,10 +1007,10 @@ declare class MultiCellSelector {
      * @param position CellPosition
      */
     singleAddClick(position: CellPositionByIndex): void;
-    multiSelectClick(position: CellPositionByIndex): void;
-    setRangeSelected(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, selected: boolean): void;
-    deselectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex): void;
-    selectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex): void;
+    multiSelectClick(position: CellPositionByIndex, options: MultiSelectRangeOptions): void;
+    setRangeSelected(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, selected: boolean, options: MultiSelectRangeOptions): void;
+    deselectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
+    selectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
 }
 
 declare type RowSelectionStateItem = (any | any[])[];
@@ -1142,7 +1194,7 @@ declare type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT
     debugName?: string;
     initSetupState?: (props: T_PROPS) => COMPONENT_SETUP_STATE;
     layoutEffect?: boolean;
-    forwardProps?: (setupState: COMPONENT_SETUP_STATE) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE>;
+    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>;
@@ -1191,6 +1243,191 @@ declare function buildManagedComponent<T_PROPS, COMPONENT_MAPPED_STATE extends o
 };
 declare function useManagedComponentState<COMPONENT_STATE>(): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
 
+declare type NodePath$1<PRIMARY_KEY_TYPE = any> = PRIMARY_KEY_TYPE[];
+declare type TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE = any> = {
+    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    defaultExpanded: boolean;
+    collapsedIds?: never;
+    expandedIds?: never;
+} | {
+    defaultExpanded: true;
+    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    expandedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
+    collapsedIds?: never;
+    expandedIds?: never;
+} | {
+    defaultExpanded: false;
+    collapsedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
+    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
+    collapsedIds?: never;
+    expandedIds?: never;
+};
+declare type TreeExpandStateObject_ById<PRIMARY_KEY_TYPE = any> = {
+    defaultExpanded: boolean;
+    expandedIds: PRIMARY_KEY_TYPE[];
+    collapsedIds: PRIMARY_KEY_TYPE[];
+    expandedPaths?: never;
+    collapsedPaths?: never;
+} | {
+    defaultExpanded: true;
+    collapsedIds: PRIMARY_KEY_TYPE[];
+    expandedIds?: PRIMARY_KEY_TYPE[];
+    expandedPaths?: never;
+    collapsedPaths?: never;
+} | {
+    defaultExpanded: false;
+    collapsedIds?: PRIMARY_KEY_TYPE[];
+    expandedIds: PRIMARY_KEY_TYPE[];
+    expandedPaths?: never;
+    collapsedPaths?: never;
+};
+declare type TreeExpandStateObject<PRIMARY_KEY_TYPE = any> = TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE> | TreeExpandStateObject_ById<PRIMARY_KEY_TYPE>;
+declare type TreeExpandStateMode = 'id' | 'path';
+declare class TreeExpandState<PRIMARY_KEY_TYPE = any> {
+    collapsedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
+    expandedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
+    collapsedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
+    expandedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
+    private _mode;
+    get mode(): TreeExpandStateMode;
+    defaultExpanded: boolean;
+    constructor(clone?: TreeExpandStateObject | TreeExpandState);
+    reset(): void;
+    destroy(): void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    expandNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
+    collapseNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
+    setNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>, expanded: boolean): void;
+    isNodeExpandedByPath(nodePath: NodePath$1<PRIMARY_KEY_TYPE>): boolean;
+    isNodeExpandedById(id: PRIMARY_KEY_TYPE): boolean;
+    isNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): boolean;
+    update(stateObject: TreeExpandStateObject): void;
+    getState(): TreeExpandStateObject;
+}
+
+declare type OnNodeStateChangeParam = DataSourceCallback_BaseParam<any> & {};
+declare type TreeDataSourceOnlyProps<T> = {
+    nodesKey?: string;
+    treeSelection?: DataSourcePropTreeSelection;
+    defaultTreeSelection?: DataSourcePropTreeSelection;
+    treeExpandState?: TreeExpandStateValue;
+    defaultTreeExpandState?: TreeExpandStateValue;
+    onTreeExpandStateChange?: (treeExpandState: TreeExpandStateObject<any>, params: {
+        dataSourceApi: DataSourceApi<T>;
+        nodePath: NodePath$1 | null;
+        nodeState: 'collapsed' | 'expanded';
+    }) => void;
+    onTreeDataMutations?: ({ dataArray, timestamp, treeMutations, nodesKey, }: {
+        nodesKey: keyof T | any;
+        dataArray: DataSourceState<T>['originalDataArray'];
+        timestamp: number;
+        treeMutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['treeMutations']>;
+    }) => void;
+    isNodeSelected?: DataSourcePropIsNodeSelected<T>;
+    /**
+     * Called when a node is expanded. Not called when treeApi.expandAll is called.
+     */
+    onNodeExpand?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
+    /**
+     * Called when a node is collapsed. Not called when treeApi.collapseAll is called.
+     */
+    onNodeCollapse?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
+} & ({
+    selectionMode?: 'multi-row';
+    treeSelection?: DataSourcePropTreeSelection_MultiNode;
+    defaultTreeSelection?: DataSourcePropTreeSelection_MultiNode;
+    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_MultiNode;
+} | {
+    selectionMode?: 'single-row';
+    treeSelection?: DataSourcePropTreeSelection_SingleNode;
+    defaultTreeSelection?: DataSourcePropTreeSelection_SingleNode;
+    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_SingleNode;
+} | {
+    selectionMode?: 'single-cell';
+    cellSelection?: DataSourcePropCellSelection_SingleCell;
+    defaultCellSelection?: DataSourcePropCellSelection_SingleCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_SingleCell;
+} | {
+    selectionMode?: 'multi-cell';
+    cellSelection?: DataSourcePropCellSelection_MultiCell;
+    defaultCellSelection?: DataSourcePropCellSelection_MultiCell;
+    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_MultiCell;
+} | {
+    selectionMode?: false;
+}) & ({
+    isNodeCollapsed?: DataSourcePropIsNodeExpanded<T>;
+    isNodeExpanded?: never;
+} | {
+    isNodeExpanded?: DataSourcePropIsNodeExpanded<T>;
+    isNodeCollapsed?: never;
+});
+declare type DataSourcePropsNotAvailableInTreeDataSource = keyof Pick<DataSourceProps<any>, 'groupBy' | 'defaultGroupBy' | 'nodesKey' | 'defaultGroupRowsState' | 'groupRowsState' | 'onGroupRowsStateChange' | 'onGroupByChange' | 'collapseGroupRowsOnDataFunctionChange' | 'livePagination' | 'onLivePaginationCursorChange' | 'groupMode' | 'onPivotByChange' | 'pivotBy' | 'defaultPivotBy' | 'selectionMode' | 'rowSelection' | 'defaultRowSelection'>;
+declare type TreeDataSourceProps<T> = Omit<DataSourceProps<T>, DataSourcePropsNotAvailableInTreeDataSource> & TreeDataSourceOnlyProps<T>;
+
+declare type NodePath = any[];
+declare type TreeSelectionStateObject = {
+    selectedPaths: NodePath;
+    deselectedPaths: NodePath;
+    defaultSelection: boolean;
+} | {
+    defaultSelection: true;
+    deselectedPaths: NodePath;
+    selectedPaths?: NodePath;
+} | {
+    defaultSelection: false;
+    selectedPaths: NodePath;
+    deselectedPaths?: NodePath;
+};
+declare type TreeSelectionStateConfig<_T = any> = {
+    treeDeepMap: DeepMap<any, DeepMapTreeValueType<any, any>>;
+};
+declare type GetTreeSelectionStateConfig<T> = () => TreeSelectionStateConfig<T>;
+declare type NodeSelectionState = {
+    selected: boolean | null;
+    selectedCount: number;
+    deselectedCount: number;
+    leafCount: number;
+};
+declare class TreeSelectionState<T = any> {
+    selectedPaths: NodePath[] | null;
+    deselectedPaths: NodePath[] | null;
+    defaultSelection: boolean;
+    selectionMap: DeepMap<NodePath, boolean>;
+    cache: DeepMap<NodePath, NodeSelectionState>;
+    getConfig: GetTreeSelectionStateConfig<T>;
+    getTreeDeepMap(): DeepMap<any, DeepMapTreeValueType<any, any>>;
+    isLeafNode(nodePath: NodePath): boolean;
+    getLeafNodesCount(nodePath: NodePath): number;
+    static from<T>(treeSelectionState: TreeSelectionStateObject, getConfig: GetTreeSelectionStateConfig<T>): TreeSelectionState<T>;
+    constructor(state: TreeSelectionStateObject | TreeSelectionState, getConfig: GetTreeSelectionStateConfig<T>);
+    setConfigFn(getConfig: GetTreeSelectionStateConfig<T>): void;
+    xcache(): void;
+    update(stateObject: TreeSelectionStateObject): void;
+    setSelectionForPath(nodePath: NodePath, selected: boolean): void;
+    getState(): TreeSelectionStateObject;
+    deselectAll(): void;
+    selectAll(): void;
+    isNodeSelected(nodePath: NodePath): boolean | null;
+    private isSelfSelected;
+    private cacheIt;
+    private getSelectionStateForNode;
+    private isPathSelected;
+    private getNodeBooleanSelectionStateFromParent;
+    setNodeSelection(nodePath: NodePath, selected: boolean): void;
+    selectNode(nodePath: NodePath): void;
+    deselectNode(nodePath: any[]): void;
+    toggleNodeSelection(nodePath: NodePath): void;
+    getSelectedCount(): number;
+    getDeselectedCount(): number;
+    getSelectionCountFor(nodePath?: NodePath): {
+        selectedCount: number;
+        deselectedCount: number;
+    };
+    destroy(): void;
+}
+
 declare type DataSourceStateRestoreForDetail<T> = {
     originalDataArray: DataSourceState<T>['originalDataArray'] | undefined;
     groupBy: DataSourceState<T>['groupBy'] | undefined;
@@ -1529,6 +1766,7 @@ interface InfiniteTableSetupState<T> {
     headerBrain: MatrixBrain;
     renderer: ReactHeadlessTableRenderer;
     onRenderUpdater: SubscriptionCallback<Renderable>;
+    forceBodyRerenderTimestamp: number;
     lastRowToExpandRef: MutableRefObject<any | null>;
     lastRowToCollapseRef: MutableRefObject<any | null>;
     getDOMNodeForCell: (cellPos: CellPositionByIndex) => HTMLElement | null;
@@ -1609,6 +1847,7 @@ declare type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropP
 interface InfiniteTableMappedState<T> {
     id: InfiniteTableProps<T>['id'];
     debugId: InfiniteTableProps<T>['debugId'];
+    debugMode: NonUndefined<InfiniteTableProps<T>['debugMode']>;
     scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
     multiSortBehavior: NonUndefined<InfiniteTableProps<T>['multiSortBehavior']>;
     viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
@@ -1616,6 +1855,7 @@ interface InfiniteTableMappedState<T> {
     groupColumn: InfiniteTableProps<T>['groupColumn'];
     onKeyDown: InfiniteTableProps<T>['onKeyDown'];
     onCellClick: InfiniteTableProps<T>['onCellClick'];
+    repeatWrappedGroupRows: InfiniteTableProps<T>['repeatWrappedGroupRows'];
     wrapRowsHorizontally: InfiniteTableProps<T>['wrapRowsHorizontally'];
     rowDetailCache: RowDetailCache<RowDetailCacheKey, RowDetailCacheEntry>;
     headerOptions: NonUndefined<InfiniteTableProps<T>['headerOptions']>;
@@ -1704,6 +1944,7 @@ interface InfiniteTableMappedState<T> {
     pivotGrandTotalColumnPosition: InfiniteTableProps<T>['pivotGrandTotalColumnPosition'];
 }
 interface InfiniteTableDerivedState<T> {
+    isTree: boolean;
     groupBy: DataSourceProps<T>['groupBy'];
     computedColumns: Record<string, InfiniteTableColumn<T>>;
     initialColumns: InfiniteTableProps<T>['columns'];
@@ -1796,6 +2037,7 @@ declare type InfiniteTableEventHandlerContext<T> = {
     getState: () => InfiniteTableState<T>;
     actions: InfiniteTableActions<T>;
     cloneRowSelection: (rowSelection: RowSelectionState<T>) => RowSelectionState<T>;
+    cloneTreeSelection: (treeSelection: TreeSelectionState<T>) => TreeSelectionState<T>;
     getDataSourceState: () => DataSourceState<T>;
     getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
     dataSourceActions: DataSourceComponentActions<T>;
@@ -1887,26 +2129,62 @@ declare type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field
     field?: keyof T | (keyof T | ((item: T) => any))[];
 };
 declare const multisort: {
-    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options?: {
+        get?: ((item: any) => T) | undefined;
+    } | ((item: any) => T) | undefined): T[];
     knownTypes: {
         [key: string]: (first: any, second: any) => number;
     };
 };
+declare type NestedMultiSortOptions<T> = {
+    get?: (item: any) => T;
+    nodesKey: string;
+    isLeafNode?: (item: T) => boolean;
+    getNodeChildren?: (item: T) => null | T[];
+    toKey: (item: T) => any;
+    depthFirst?: boolean;
+    inplace?: boolean;
+};
+declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];
 
 declare 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: '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;
@@ -1920,24 +2198,57 @@ declare class DataSourceCache<DataType, PrimaryKeyType = string> {
     private affectedFields;
     private allFieldsAffected;
     private primaryKeyToData;
+    private nodePathToData;
     static clone<DataType, PrimaryKeyType = string>(cache: DataSourceCache<DataType, PrimaryKeyType>, { light }?: {
         light?: boolean;
     }): DataSourceCache<DataType, PrimaryKeyType>;
     getAffectedFields: () => true | Set<keyof DataType>;
     delete: (primaryKey: PrimaryKeyType, originalData: DataType, metadata: any) => void;
+    deleteNodePath: (nodePath: NodePath$1<any>, originalData: DataType, metadata: any) => void;
     insert: (primaryKey: PrimaryKeyType, data: DataType, position: 'before' | 'after', metadata: any) => void;
+    insertNodePath: (nodePath: NodePath$1<any>, data: DataType, position: 'before' | 'after', metadata: any) => void;
     update: (primaryKey: PrimaryKeyType, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
+    updateNodePath: (nodePath: NodePath$1<any>, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
     resetDataSource: (metadata: any) => void;
     shouldResetDataSource: () => boolean;
     clear: () => void;
     isEmpty: () => boolean;
     removeInfo: (primaryKey: PrimaryKeyType) => void;
+    removeNodePathInfo: (nodePath: NodePath$1<any>) => void;
     getMutationsForPrimaryKey: (primaryKey: PrimaryKeyType) => DataSourceMutation<DataType>[] | undefined;
+    getMutationsForNodePath: (nodePath: NodePath$1<any>) => DataSourceMutation<DataType>[] | undefined;
     getMutationsCount: () => number;
     getMutations: () => Map<PrimaryKeyType, DataSourceMutation<DataType>[]>;
+    getTreeMutations: () => DeepMap<NodePath$1<any>, DataSourceMutation<DataType>[]>;
     getMutationsArray: () => DataSourceMutation<DataType>[];
 }
 
+declare type TreeExpandStateApi<T> = {
+    isNodeExpanded(nodePath: any[]): boolean;
+    expandNode(nodePath: any[]): void;
+    collapseNode(nodePath: any[]): void;
+    toggleNode(nodePath: any[]): void;
+    getNodeDataByPath(nodePath: any[]): T | null;
+    getRowInfoByPath(nodePath: any[]): InfiniteTableRowInfo<T> | null;
+};
+declare type TreeSelectionApi<T> = {
+    get allRowsSelected(): boolean;
+    isNodeSelected(nodePath: NodePath$1): boolean | null;
+    selectNode(nodePath: NodePath$1): void;
+    setNodeSelection(nodePath: NodePath$1, selected: boolean): void;
+    deselectNode(nodePath: NodePath$1): void;
+    toggleNodeSelection(nodePath: NodePath$1): void;
+    getRowInfoByNodePath(nodePath: NodePath$1): InfiniteTableRowInfo<T> | null;
+    getIndexByNodePath(nodePath: NodePath$1): number;
+    getDataByNodePath(nodePath: NodePath$1): T | null;
+    selectAll(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    deselectAll(): void;
+    updateDataByNodePath(data: Partial<T>, nodePath: NodePath$1, options?: DataSourceCRUDParam): void;
+};
+declare type TreeApi<T> = TreeExpandStateApi<T> & TreeSelectionApi<T>;
+
 declare type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
 declare type BooleanDeepCollectionStateObject<KeyType> = {
     positiveItems: BooleanDeepCollectionStateKeys<KeyType>;
@@ -1987,12 +2298,18 @@ declare class GroupRowsState<KeyType extends any = any> extends BooleanDeepColle
 
 declare class Indexer<DataType, PrimaryKeyType = string> {
     primaryKeyToData: Map<PrimaryKeyType, DataType>;
+    nodePathsToData: DeepMap<PrimaryKeyType, DataType>;
     private add;
+    private addNodePath;
     clear: () => void;
     getDataForPrimaryKey: (primaryKey: PrimaryKeyType) => DataType | undefined;
+    getDataForNodePath: (nodePath: NodePath$1<any>) => DataType | undefined;
     indexArray: (arr: DataType[], options: {
         toPrimaryKey: (data: DataType) => PrimaryKeyType;
         cache?: DataSourceCache<DataType, PrimaryKeyType> | undefined;
+        getNodeChildren?: ((item: DataType) => DataType[] | null) | undefined;
+        isLeafNode?: ((item: DataType) => boolean) | undefined;
+        nodesKey: string | undefined;
     }) => DataType[];
 }
 
@@ -2072,11 +2389,20 @@ interface DataSourceMappedState<T> {
     livePagination: DataSourceProps<T>['livePagination'];
     refetchKey: NonUndefined<DataSourceProps<T>['refetchKey']>;
     isRowSelected: DataSourceProps<T>['isRowSelected'];
+    isNodeSelected: TreeDataSourceProps<T>['isNodeSelected'];
+    isNodeExpanded: TreeDataSourceProps<T>['isNodeExpanded'];
+    isNodeCollapsed: TreeDataSourceProps<T>['isNodeCollapsed'];
+    onNodeCollapse: TreeDataSourceProps<T>['onNodeCollapse'];
+    onNodeExpand: TreeDataSourceProps<T>['onNodeExpand'];
     isRowDisabled: DataSourceProps<T>['isRowDisabled'];
     debugId: DataSourceProps<T>['debugId'];
+    debugMode: DataSourceProps<T>['debugMode'];
+    nodesKey: NonUndefined<TreeDataSourceProps<T>['nodesKey']>;
+    treeSelection: TreeDataSourceProps<T>['treeSelection'];
     batchOperationDelay: DataSourceProps<T>['batchOperationDelay'];
     onDataArrayChange: DataSourceProps<T>['onDataArrayChange'];
     onDataMutations: DataSourceProps<T>['onDataMutations'];
+    onTreeDataMutations: TreeDataSourceProps<T>['onTreeDataMutations'];
     onReady: DataSourceProps<T>['onReady'];
     rowInfoReducers: DataSourceProps<T>['rowInfoReducers'];
     lazyLoad: DataSourceProps<T>['lazyLoad'];
@@ -2144,9 +2470,24 @@ declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType,
 interface DataSourceSetupState<T> {
     indexer: Indexer<T, any>;
     getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
+    __apiRef: React$1.MutableRefObject<DataSourceApi<T> | null>;
+    lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
+    lastExpandStateInfoRef: React$1.MutableRefObject<{
+        state: 'collapsed' | 'expanded';
+        nodePath: NodePath$1 | null;
+    }>;
+    repeatWrappedGroupRows: InfiniteTablePropRepeatWrappedGroupRows<T>;
+    /**
+     * This is just used for horizontal layout and when repeatWrappedGroupRows is TRUE!!!
+     */
+    rowsPerPage: number | null;
+    totalLeafNodesCount: number;
     destroyedRef: React$1.MutableRefObject<boolean>;
     idToIndexMap: Map<any, number>;
+    idToPathMap: Map<any, NodePath$1>;
+    pathToIndexDeepMap: DeepMap<any, number>;
     detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+    treeSelectionState?: TreeSelectionState;
     stateReadyAsDetails: boolean;
     cache?: DataSourceCache<T>;
     unfilteredCount: number;
@@ -2156,6 +2497,7 @@ interface DataSourceSetupState<T> {
     originalDataArrayChangedInfo: {
         timestamp: number;
         mutations?: Map<string, DataSourceMutation<T>[]>;
+        treeMutations?: DeepMap<any, DataSourceMutation<T>[]>;
     };
     lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
     pivotMappings?: DataSourceMappings;
@@ -2173,8 +2515,11 @@ interface DataSourceSetupState<T> {
     lastFilterDataArray?: T[];
     lastSortDataArray?: T[];
     lastGroupDataArray?: InfiniteTableRowInfo<T>[];
+    lastTreeDataArray?: InfiniteTableRowInfo<T>[];
     dataArray: InfiniteTableRowInfo<T>[];
     groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
+    treeDeepMap?: DeepMap<TreeKeyType, DeepMapTreeValueType<T, any>>;
+    treePaths?: DeepMap<TreeKeyType, any>;
     groupRowsIndexesInDataArray?: number[];
     reducerResults?: Record<string, AggregationReducerResult>;
     allRowsSelected: boolean;
@@ -2185,6 +2530,7 @@ interface DataSourceSetupState<T> {
     updatedAt: number;
     reducedAt: number;
     groupedAt: number;
+    treeAt: number;
     sortedAt: number;
     filteredAt: number;
     generateGroupRows: boolean;
@@ -2198,41 +2544,74 @@ declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAgg
 declare type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
 declare type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
 declare type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
+declare type TreeSelectionValue = TreeSelectionStateObject | TreeSelectionState;
+declare type DataSourcePropTreeSelection_MultiNode = TreeSelectionValue;
 declare type DataSourcePropRowSelection_SingleRow = null | string | number;
+declare type DataSourcePropTreeSelection_SingleNode = null | string | number;
+declare type DataSourcePropTreeSelection = DataSourcePropTreeSelection_MultiNode | DataSourcePropTreeSelection_SingleNode;
 declare type DataSourcePropCellSelection_MultiCell = CellSelectionStateObject | CellSelectionState;
 declare type DataSourcePropCellSelection_SingleCell = null | CellSelectionPosition;
 declare type DataSourcePropCellSelection = DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
 declare type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
 declare type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
+declare type DataSourcePropOnTreeSelectionChange_MultiNode<T = any> = (treeSelection: TreeSelectionStateObject, params: {
+    selectionMode: 'multi-row';
+    lastUpdatedNodePath: NodePath$1 | null;
+    dataSourceApi: DataSourceApi<T>;
+}) => void;
 declare type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
+declare type DataSourcePropOnTreeSelectionChange_SingleNode = (treeSelection: DataSourcePropTreeSelection_SingleNode, params: {
+    selectionMode: 'single-row';
+}) => void;
 declare type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
+declare type DataSourcePropOnTreeSelectionChange = DataSourcePropOnTreeSelectionChange_SingleNode | DataSourcePropOnTreeSelectionChange_MultiNode;
 declare type DataSourcePropOnCellSelectionChange_MultiCell = (cellSelection: DataSourcePropCellSelection_MultiCell, selectionMode: 'multi-cell') => void;
 declare type DataSourcePropOnCellSelectionChange_SingleCell = (cellSelection: DataSourcePropCellSelection_SingleCell, selectionMode: 'single-cell') => void;
 declare type DataSourcePropOnCellSelectionChange = DataSourcePropOnCellSelectionChange_MultiCell | DataSourcePropOnCellSelectionChange_SingleCell;
 declare type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
+declare type DataSourcePropIsNodeSelected<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T> | InfiniteTable_Tree_RowInfoLeafNode<T>, treeSelectionState: TreeSelectionState, selectionMode: 'multi-row') => boolean | null;
+declare type DataSourcePropIsNodeExpanded<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>) => boolean;
 declare type DataSourcePropSortFn<T> = (sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: (item: any) => T) => T[];
 declare type DataSourceCRUDParam = {
     flush?: boolean;
     metadata?: any;
 };
+declare type DataSourceUpdateParam = DataSourceCRUDParam & {};
 declare type DataSourceInsertParam = DataSourceCRUDParam & ({
     position: 'before' | 'after';
     primaryKey: any;
+    nodePath?: never;
+} | {
+    position: 'before' | 'after';
+    primaryKey?: never;
+    nodePath: NodePath$1;
+} | {
+    position: 'start' | 'end';
+    nodePath?: never;
 } | {
     position: 'start' | 'end';
+    nodePath: NodePath$1;
 });
 interface DataSourceApi<T> {
     getOriginalDataArray: () => T[];
     getRowInfoArray: () => InfiniteTableRowInfo<T>[];
     getDataByPrimaryKey(id: any): T | null;
+    getDataByNodePath(nodePath: NodePath$1): T | null;
     getRowInfoByIndex(index: number): InfiniteTableRowInfo<T> | null;
     getRowInfoByPrimaryKey(id: any): InfiniteTableRowInfo<T> | null;
+    getRowInfoByNodePath(nodePath: NodePath$1): InfiniteTableRowInfo<T> | null;
     getIndexByPrimaryKey(id: any): number;
+    getIndexByNodePath(nodePath: NodePath$1): number;
     getPrimaryKeyByIndex(id: any): any;
+    getNodePathById(id: any): NodePath$1 | null;
+    get treeApi(): TreeApi<T>;
     updateData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
+    updateDataByNodePath(data: Partial<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
     updateDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
+    updateDataArrayByNodePath(data: Partial<T>[], nodePaths: NodePath$1[], options?: DataSourceUpdateParam): Promise<any>;
     flush(): Promise<any>;
     removeDataByPrimaryKey(id: any, options?: DataSourceCRUDParam): Promise<any>;
+    removeDataByNodePath(nodePath: NodePath$1, options?: DataSourceCRUDParam): Promise<any>;
     removeDataArrayByPrimaryKeys(id: any[], options?: DataSourceCRUDParam): Promise<any>;
     removeData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
     removeDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
@@ -2257,9 +2636,12 @@ declare type DataSourceRowInfoReducer<T> = DataSourceRawReducer<InfiniteTableRow
 declare type DataSourcePropShouldReloadDataObject<T> = {
     [key in keyof Pick<DataSourceDataParams<T>, 'sortInfo' | 'pivotBy' | 'groupBy' | 'filterValue'>]: boolean;
 };
-declare type DataSourcePropShouldReloadData<T> = DataSourcePropShouldReloadDataObject<T>;
+declare type DataSourcePropShouldReloadData<T> = DataSourcePropShouldReloadDataObject<T> | boolean;
+declare type TreeExpandStateValue = TreeExpandState | TreeExpandStateObject<any>;
 declare type DataSourceProps<T> = {
+    nodesKey?: never;
     debugId?: string;
+    debugMode?: InfiniteTablePropDebugMode;
     children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
     primaryKey: keyof T | ((data: T) => string);
     /**
@@ -2272,8 +2654,8 @@ declare type DataSourceProps<T> = {
     data: DataSourceData<T>;
     selectionMode?: DataSourcePropSelectionMode;
     useGroupKeysForMultiRowSelection?: boolean;
-    rowSelection?: DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
-    defaultRowSelection?: DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
+    rowSelection?: DataSourcePropRowSelection;
+    defaultRowSelection?: DataSourcePropRowSelection;
     cellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
     defaultCellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
     onCellSelectionChange?: DataSourcePropOnCellSelectionChange;
@@ -2427,15 +2809,21 @@ declare type DataSourceLivePaginationCursorParams<T> = {
 declare type DataSourceLivePaginationCursorValue = string | number | null;
 interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
 }
+declare type DataSourceCallback_BaseParam<T> = {
+    dataSourceApi: DataSourceApi<T>;
+};
 declare type DataSourceDerivedState<T> = {
+    isTree: boolean;
     toPrimaryKey: (data: T) => any;
     operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
     sortMode: 'local' | 'remote';
     filterMode: 'local' | 'remote';
     groupMode: 'local' | 'remote';
     pivotMode: 'local' | 'remote';
-    shouldReloadData: NonUndefined<Required<DataSourcePropShouldReloadData<T>>>;
+    shouldReloadData: NonUndefined<Required<DataSourcePropShouldReloadDataObject<T>>>;
     groupRowsState: GroupRowsState<T>;
+    treeExpandState: TreeExpandState<any>;
+    treeExpandMode: TreeExpandStateMode;
     multiSort: boolean;
     controlledSort: boolean;
     controlledFilter: boolean;
@@ -2482,6 +2870,7 @@ declare function useInfiniteHeaderCell<T>(): {
     someRowsSelected: boolean;
     filtered: boolean;
     api: InfiniteTableApi<T>;
+    dataSourceApi: DataSourceApi<T>;
     columnApi: InfiniteTableColumnApi<T>;
     renderBag: {
         all?: Renderable;
@@ -2490,13 +2879,16 @@ declare function useInfiniteHeaderCell<T>(): {
         menuIcon?: Renderable;
         menuIconProps?: MenuIconProps | undefined;
         filterIcon?: Renderable;
+        filterEditor?: Renderable;
         selectionCheckBox?: Renderable;
     };
 } & {
     domRef: ((instance: HTMLElement | null) => void) | undefined;
+    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
     insideColumnMenu: false;
 } & {
     domRef: ((instance: HTMLElement | null) => void) | undefined;
+    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
     insideColumnMenu: false;
 };
 
@@ -2550,6 +2942,8 @@ declare function useVisibleColumnSizes(): {
     pinned: InfiniteTableColumnPinnedValues;
 }[];
 
+declare function useInfinitePortalContainer(): HTMLDivElement | null;
+
 declare const InfiniteTableClassName: string;
 declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => React$1.JSX.Element)>;
 declare type InfiniteTableComponent = {
@@ -2571,9 +2965,21 @@ declare const useManagedDataSource: (props: unknown) => {
         componentState: {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -2583,10 +2989,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -2600,8 +3007,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -2612,6 +3022,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -2620,14 +3031,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -2641,10 +3055,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -2667,9 +3090,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -2679,10 +3114,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -2696,8 +3132,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -2708,6 +3147,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -2716,14 +3156,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -2737,10 +3180,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -2763,9 +3215,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -2775,10 +3239,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -2792,8 +3257,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -2804,6 +3272,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -2812,14 +3281,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -2833,10 +3305,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -2860,9 +3341,21 @@ declare const useManagedDataSource: (props: unknown) => {
         componentActions: ComponentStateGeneratedActions<{
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -2872,10 +3365,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -2889,8 +3383,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -2901,6 +3398,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -2909,14 +3407,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -2930,10 +3431,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -2956,9 +3466,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -2968,10 +3490,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -2985,8 +3508,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -2997,6 +3523,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3005,14 +3532,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3026,10 +3556,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3052,9 +3591,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3064,10 +3615,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3081,8 +3633,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3093,6 +3648,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3101,14 +3657,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3122,10 +3681,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3149,9 +3717,21 @@ declare const useManagedDataSource: (props: unknown) => {
         getComponentState: () => {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3161,10 +3741,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3178,8 +3759,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3190,6 +3774,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3198,14 +3783,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3219,10 +3807,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3245,9 +3842,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3257,10 +3866,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3274,8 +3884,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3286,6 +3899,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3294,14 +3908,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3315,10 +3932,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3341,9 +3967,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3353,10 +3991,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3370,8 +4009,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3382,6 +4024,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3390,14 +4033,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3411,10 +4057,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3438,9 +4093,21 @@ declare const useManagedDataSource: (props: unknown) => {
         replaceState: (newState: {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3450,10 +4117,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3467,8 +4135,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3479,6 +4150,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3487,14 +4159,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3508,10 +4183,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3534,9 +4218,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3546,10 +4242,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3563,8 +4260,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3575,6 +4275,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3583,14 +4284,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3604,10 +4308,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3630,9 +4343,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3642,10 +4367,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3659,8 +4385,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3671,6 +4400,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3679,14 +4409,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3700,10 +4433,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3727,9 +4469,21 @@ declare const useManagedDataSource: (props: unknown) => {
         assignState: (newState: Partial<{
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3739,10 +4493,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3756,8 +4511,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3768,6 +4526,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3776,14 +4535,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3797,10 +4559,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3823,9 +4594,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3835,10 +4618,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3852,8 +4636,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3864,6 +4651,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3872,14 +4660,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3893,10 +4684,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -3919,9 +4719,21 @@ declare const useManagedDataSource: (props: unknown) => {
         } & {
             indexer: Indexer<unknown, any>;
             getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+            lastExpandStateInfoRef: React$1.MutableRefObject<{
+                state: "expanded" | "collapsed";
+                nodePath: NodePath$1<any> | null;
+            }>;
+            repeatWrappedGroupRows: never;
+            rowsPerPage: never;
+            totalLeafNodesCount: number;
             destroyedRef: React$1.MutableRefObject<boolean>;
             idToIndexMap: Map<any, number>;
+            idToPathMap: Map<any, NodePath$1<any>>;
+            pathToIndexDeepMap: DeepMap<any, number>;
             detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            treeSelectionState?: never;
             stateReadyAsDetails: never;
             cache?: never;
             unfilteredCount: number;
@@ -3931,10 +4743,11 @@ declare const useManagedDataSource: (props: unknown) => {
             originalDataArrayChangedInfo: {
                 timestamp: number;
                 mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
             };
             lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
             pivotMappings?: never;
-            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
             showSeparatePivotColumnForSingleAggregation: never;
             dataParams?: never;
             originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -3948,8 +4761,11 @@ declare const useManagedDataSource: (props: unknown) => {
             lastFilterDataArray?: never;
             lastSortDataArray?: never;
             lastGroupDataArray?: never;
+            lastTreeDataArray?: never;
             dataArray: InfiniteTableRowInfo<unknown>[];
             groupDeepMap?: never;
+            treeDeepMap?: never;
+            treePaths?: never;
             groupRowsIndexesInDataArray?: never;
             reducerResults?: never;
             allRowsSelected: never;
@@ -3960,6 +4776,7 @@ declare const useManagedDataSource: (props: unknown) => {
             updatedAt: number;
             reducedAt: number;
             groupedAt: number;
+            treeAt: number;
             sortedAt: number;
             filteredAt: number;
             generateGroupRows: never;
@@ -3968,14 +4785,17 @@ declare const useManagedDataSource: (props: unknown) => {
             postGroupDataArray?: never;
             pivotColumns?: never;
             pivotColumnGroups?: never;
+            isTree: never;
             toPrimaryKey: (data: unknown) => any;
             operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
             sortMode: never;
             filterMode: never;
             groupMode: never;
             pivotMode: never;
-            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
             groupRowsState: GroupRowsState<unknown>;
+            treeExpandState: TreeExpandState<any>;
+            treeExpandMode: never;
             multiSort: never;
             controlledSort: never;
             controlledFilter: never;
@@ -3989,10 +4809,19 @@ declare const useManagedDataSource: (props: unknown) => {
             livePagination: never;
             refetchKey: never;
             isRowSelected: never;
+            isNodeSelected: never;
+            isNodeExpanded: never;
+            isNodeCollapsed: never;
+            onNodeCollapse: never;
+            onNodeExpand: never;
             debugId: never;
+            debugMode: never;
+            nodesKey: string;
+            treeSelection: never;
             batchOperationDelay: never;
             onDataArrayChange: never;
             onDataMutations: never;
+            onTreeDataMutations: never;
             onReady: never;
             rowInfoReducers: never;
             lazyLoad: never;
@@ -4017,9 +4846,21 @@ declare const useManagedDataSource: (props: unknown) => {
     ContextComponent: React$1.Context<ManagedComponentStateContextValue<{
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+        lastExpandStateInfoRef: React$1.MutableRefObject<{
+            state: "expanded" | "collapsed";
+            nodePath: NodePath$1<any> | null;
+        }>;
+        repeatWrappedGroupRows: never;
+        rowsPerPage: never;
+        totalLeafNodesCount: number;
         destroyedRef: React$1.MutableRefObject<boolean>;
         idToIndexMap: Map<any, number>;
+        idToPathMap: Map<any, NodePath$1<any>>;
+        pathToIndexDeepMap: DeepMap<any, number>;
         detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        treeSelectionState?: never;
         stateReadyAsDetails: never;
         cache?: never;
         unfilteredCount: number;
@@ -4029,10 +4870,11 @@ declare const useManagedDataSource: (props: unknown) => {
         originalDataArrayChangedInfo: {
             timestamp: number;
             mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4046,8 +4888,11 @@ declare const useManagedDataSource: (props: unknown) => {
         lastFilterDataArray?: never;
         lastSortDataArray?: never;
         lastGroupDataArray?: never;
+        lastTreeDataArray?: never;
         dataArray: InfiniteTableRowInfo<unknown>[];
         groupDeepMap?: never;
+        treeDeepMap?: never;
+        treePaths?: never;
         groupRowsIndexesInDataArray?: never;
         reducerResults?: never;
         allRowsSelected: never;
@@ -4058,6 +4903,7 @@ declare const useManagedDataSource: (props: unknown) => {
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
+        treeAt: number;
         sortedAt: number;
         filteredAt: number;
         generateGroupRows: never;
@@ -4066,14 +4912,17 @@ declare const useManagedDataSource: (props: unknown) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
         sortMode: never;
         filterMode: never;
         groupMode: never;
         pivotMode: never;
-        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
         groupRowsState: GroupRowsState<unknown>;
+        treeExpandState: TreeExpandState<any>;
+        treeExpandMode: never;
         multiSort: never;
         controlledSort: never;
         controlledFilter: never;
@@ -4087,10 +4936,19 @@ declare const useManagedDataSource: (props: unknown) => {
         livePagination: never;
         refetchKey: never;
         isRowSelected: never;
+        isNodeSelected: never;
+        isNodeExpanded: never;
+        isNodeCollapsed: never;
+        onNodeCollapse: never;
+        onNodeExpand: never;
         debugId: never;
+        debugMode: never;
+        nodesKey: string;
+        treeSelection: never;
         batchOperationDelay: never;
         onDataArrayChange: never;
         onDataMutations: never;
+        onTreeDataMutations: never;
         onReady: never;
         rowInfoReducers: never;
         lazyLoad: never;
@@ -4113,9 +4971,21 @@ declare const useManagedDataSource: (props: unknown) => {
     } & {
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+        lastExpandStateInfoRef: React$1.MutableRefObject<{
+            state: "expanded" | "collapsed";
+            nodePath: NodePath$1<any> | null;
+        }>;
+        repeatWrappedGroupRows: never;
+        rowsPerPage: never;
+        totalLeafNodesCount: number;
         destroyedRef: React$1.MutableRefObject<boolean>;
         idToIndexMap: Map<any, number>;
+        idToPathMap: Map<any, NodePath$1<any>>;
+        pathToIndexDeepMap: DeepMap<any, number>;
         detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        treeSelectionState?: never;
         stateReadyAsDetails: never;
         cache?: never;
         unfilteredCount: number;
@@ -4125,10 +4995,11 @@ declare const useManagedDataSource: (props: unknown) => {
         originalDataArrayChangedInfo: {
             timestamp: number;
             mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4142,8 +5013,11 @@ declare const useManagedDataSource: (props: unknown) => {
         lastFilterDataArray?: never;
         lastSortDataArray?: never;
         lastGroupDataArray?: never;
+        lastTreeDataArray?: never;
         dataArray: InfiniteTableRowInfo<unknown>[];
         groupDeepMap?: never;
+        treeDeepMap?: never;
+        treePaths?: never;
         groupRowsIndexesInDataArray?: never;
         reducerResults?: never;
         allRowsSelected: never;
@@ -4154,6 +5028,7 @@ declare const useManagedDataSource: (props: unknown) => {
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
+        treeAt: number;
         sortedAt: number;
         filteredAt: number;
         generateGroupRows: never;
@@ -4162,14 +5037,17 @@ declare const useManagedDataSource: (props: unknown) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
         sortMode: never;
         filterMode: never;
         groupMode: never;
         pivotMode: never;
-        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
         groupRowsState: GroupRowsState<unknown>;
+        treeExpandState: TreeExpandState<any>;
+        treeExpandMode: never;
         multiSort: never;
         controlledSort: never;
         controlledFilter: never;
@@ -4183,10 +5061,19 @@ declare const useManagedDataSource: (props: unknown) => {
         livePagination: never;
         refetchKey: never;
         isRowSelected: never;
+        isNodeSelected: never;
+        isNodeExpanded: never;
+        isNodeCollapsed: never;
+        onNodeCollapse: never;
+        onNodeExpand: never;
         debugId: never;
+        debugMode: never;
+        nodesKey: string;
+        treeSelection: never;
         batchOperationDelay: never;
         onDataArrayChange: never;
         onDataMutations: never;
+        onTreeDataMutations: never;
         onReady: never;
         rowInfoReducers: never;
         lazyLoad: never;
@@ -4209,9 +5096,21 @@ declare const useManagedDataSource: (props: unknown) => {
     } & {
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+        lastExpandStateInfoRef: React$1.MutableRefObject<{
+            state: "expanded" | "collapsed";
+            nodePath: NodePath$1<any> | null;
+        }>;
+        repeatWrappedGroupRows: never;
+        rowsPerPage: never;
+        totalLeafNodesCount: number;
         destroyedRef: React$1.MutableRefObject<boolean>;
         idToIndexMap: Map<any, number>;
+        idToPathMap: Map<any, NodePath$1<any>>;
+        pathToIndexDeepMap: DeepMap<any, number>;
         detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        treeSelectionState?: never;
         stateReadyAsDetails: never;
         cache?: never;
         unfilteredCount: number;
@@ -4221,10 +5120,11 @@ declare const useManagedDataSource: (props: unknown) => {
         originalDataArrayChangedInfo: {
             timestamp: number;
             mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4238,8 +5138,11 @@ declare const useManagedDataSource: (props: unknown) => {
         lastFilterDataArray?: never;
         lastSortDataArray?: never;
         lastGroupDataArray?: never;
+        lastTreeDataArray?: never;
         dataArray: InfiniteTableRowInfo<unknown>[];
         groupDeepMap?: never;
+        treeDeepMap?: never;
+        treePaths?: never;
         groupRowsIndexesInDataArray?: never;
         reducerResults?: never;
         allRowsSelected: never;
@@ -4250,6 +5153,7 @@ declare const useManagedDataSource: (props: unknown) => {
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
+        treeAt: number;
         sortedAt: number;
         filteredAt: number;
         generateGroupRows: never;
@@ -4258,14 +5162,17 @@ declare const useManagedDataSource: (props: unknown) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
         sortMode: never;
         filterMode: never;
         groupMode: never;
         pivotMode: never;
-        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
         groupRowsState: GroupRowsState<unknown>;
+        treeExpandState: TreeExpandState<any>;
+        treeExpandMode: never;
         multiSort: never;
         controlledSort: never;
         controlledFilter: never;
@@ -4279,10 +5186,19 @@ declare const useManagedDataSource: (props: unknown) => {
         livePagination: never;
         refetchKey: never;
         isRowSelected: never;
+        isNodeSelected: never;
+        isNodeExpanded: never;
+        isNodeCollapsed: never;
+        onNodeCollapse: never;
+        onNodeExpand: never;
         debugId: never;
+        debugMode: never;
+        nodesKey: string;
+        treeSelection: never;
         batchOperationDelay: never;
         onDataArrayChange: never;
         onDataMutations: never;
+        onTreeDataMutations: never;
         onReady: never;
         rowInfoReducers: never;
         lazyLoad: never;
@@ -4305,9 +5221,21 @@ declare const useManagedDataSource: (props: unknown) => {
     }, ComponentStateGeneratedActions<{
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+        lastExpandStateInfoRef: React$1.MutableRefObject<{
+            state: "expanded" | "collapsed";
+            nodePath: NodePath$1<any> | null;
+        }>;
+        repeatWrappedGroupRows: never;
+        rowsPerPage: never;
+        totalLeafNodesCount: number;
         destroyedRef: React$1.MutableRefObject<boolean>;
         idToIndexMap: Map<any, number>;
+        idToPathMap: Map<any, NodePath$1<any>>;
+        pathToIndexDeepMap: DeepMap<any, number>;
         detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        treeSelectionState?: never;
         stateReadyAsDetails: never;
         cache?: never;
         unfilteredCount: number;
@@ -4317,10 +5245,11 @@ declare const useManagedDataSource: (props: unknown) => {
         originalDataArrayChangedInfo: {
             timestamp: number;
             mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4334,8 +5263,11 @@ declare const useManagedDataSource: (props: unknown) => {
         lastFilterDataArray?: never;
         lastSortDataArray?: never;
         lastGroupDataArray?: never;
+        lastTreeDataArray?: never;
         dataArray: InfiniteTableRowInfo<unknown>[];
         groupDeepMap?: never;
+        treeDeepMap?: never;
+        treePaths?: never;
         groupRowsIndexesInDataArray?: never;
         reducerResults?: never;
         allRowsSelected: never;
@@ -4346,6 +5278,7 @@ declare const useManagedDataSource: (props: unknown) => {
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
+        treeAt: number;
         sortedAt: number;
         filteredAt: number;
         generateGroupRows: never;
@@ -4354,14 +5287,17 @@ declare const useManagedDataSource: (props: unknown) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
         sortMode: never;
         filterMode: never;
         groupMode: never;
         pivotMode: never;
-        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
         groupRowsState: GroupRowsState<unknown>;
+        treeExpandState: TreeExpandState<any>;
+        treeExpandMode: never;
         multiSort: never;
         controlledSort: never;
         controlledFilter: never;
@@ -4375,10 +5311,19 @@ declare const useManagedDataSource: (props: unknown) => {
         livePagination: never;
         refetchKey: never;
         isRowSelected: never;
+        isNodeSelected: never;
+        isNodeExpanded: never;
+        isNodeCollapsed: never;
+        onNodeCollapse: never;
+        onNodeExpand: never;
         debugId: never;
+        debugMode: never;
+        nodesKey: string;
+        treeSelection: never;
         batchOperationDelay: never;
         onDataArrayChange: never;
         onDataMutations: never;
+        onTreeDataMutations: never;
         onReady: never;
         rowInfoReducers: never;
         lazyLoad: never;
@@ -4401,9 +5346,21 @@ declare const useManagedDataSource: (props: unknown) => {
     } & {
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+        lastExpandStateInfoRef: React$1.MutableRefObject<{
+            state: "expanded" | "collapsed";
+            nodePath: NodePath$1<any> | null;
+        }>;
+        repeatWrappedGroupRows: never;
+        rowsPerPage: never;
+        totalLeafNodesCount: number;
         destroyedRef: React$1.MutableRefObject<boolean>;
         idToIndexMap: Map<any, number>;
+        idToPathMap: Map<any, NodePath$1<any>>;
+        pathToIndexDeepMap: DeepMap<any, number>;
         detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        treeSelectionState?: never;
         stateReadyAsDetails: never;
         cache?: never;
         unfilteredCount: number;
@@ -4413,10 +5370,11 @@ declare const useManagedDataSource: (props: unknown) => {
         originalDataArrayChangedInfo: {
             timestamp: number;
             mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4430,8 +5388,11 @@ declare const useManagedDataSource: (props: unknown) => {
         lastFilterDataArray?: never;
         lastSortDataArray?: never;
         lastGroupDataArray?: never;
+        lastTreeDataArray?: never;
         dataArray: InfiniteTableRowInfo<unknown>[];
         groupDeepMap?: never;
+        treeDeepMap?: never;
+        treePaths?: never;
         groupRowsIndexesInDataArray?: never;
         reducerResults?: never;
         allRowsSelected: never;
@@ -4442,6 +5403,7 @@ declare const useManagedDataSource: (props: unknown) => {
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
+        treeAt: number;
         sortedAt: number;
         filteredAt: number;
         generateGroupRows: never;
@@ -4450,14 +5412,17 @@ declare const useManagedDataSource: (props: unknown) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
         sortMode: never;
         filterMode: never;
         groupMode: never;
         pivotMode: never;
-        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
         groupRowsState: GroupRowsState<unknown>;
+        treeExpandState: TreeExpandState<any>;
+        treeExpandMode: never;
         multiSort: never;
         controlledSort: never;
         controlledFilter: never;
@@ -4471,10 +5436,19 @@ declare const useManagedDataSource: (props: unknown) => {
         livePagination: never;
         refetchKey: never;
         isRowSelected: never;
+        isNodeSelected: never;
+        isNodeExpanded: never;
+        isNodeCollapsed: never;
+        onNodeCollapse: never;
+        onNodeExpand: never;
         debugId: never;
+        debugMode: never;
+        nodesKey: string;
+        treeSelection: never;
         batchOperationDelay: never;
         onDataArrayChange: never;
         onDataMutations: never;
+        onTreeDataMutations: never;
         onReady: never;
         rowInfoReducers: never;
         lazyLoad: never;
@@ -4497,9 +5471,21 @@ declare const useManagedDataSource: (props: unknown) => {
     } & {
         indexer: Indexer<unknown, any>;
         getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
+        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1<any> | null>;
+        lastExpandStateInfoRef: React$1.MutableRefObject<{
+            state: "expanded" | "collapsed";
+            nodePath: NodePath$1<any> | null;
+        }>;
+        repeatWrappedGroupRows: never;
+        rowsPerPage: never;
+        totalLeafNodesCount: number;
         destroyedRef: React$1.MutableRefObject<boolean>;
         idToIndexMap: Map<any, number>;
+        idToPathMap: Map<any, NodePath$1<any>>;
+        pathToIndexDeepMap: DeepMap<any, number>;
         detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        treeSelectionState?: never;
         stateReadyAsDetails: never;
         cache?: never;
         unfilteredCount: number;
@@ -4509,10 +5495,11 @@ declare const useManagedDataSource: (props: unknown) => {
         originalDataArrayChangedInfo: {
             timestamp: number;
             mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
         };
         lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
         pivotMappings?: never;
-        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        propsCache: Map<"children" | "nodesKey" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "isRowDisabled" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "debugMode" | "batchOperationDelay" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "rowDisabledState" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultRowDisabledState" | "onRowDisabledStateChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: never;
         dataParams?: never;
         originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
@@ -4526,8 +5513,11 @@ declare const useManagedDataSource: (props: unknown) => {
         lastFilterDataArray?: never;
         lastSortDataArray?: never;
         lastGroupDataArray?: never;
+        lastTreeDataArray?: never;
         dataArray: InfiniteTableRowInfo<unknown>[];
         groupDeepMap?: never;
+        treeDeepMap?: never;
+        treePaths?: never;
         groupRowsIndexesInDataArray?: never;
         reducerResults?: never;
         allRowsSelected: never;
@@ -4538,6 +5528,7 @@ declare const useManagedDataSource: (props: unknown) => {
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
+        treeAt: number;
         sortedAt: number;
         filteredAt: number;
         generateGroupRows: never;
@@ -4546,14 +5537,17 @@ declare const useManagedDataSource: (props: unknown) => {
         postGroupDataArray?: never;
         pivotColumns?: never;
         pivotColumnGroups?: never;
+        isTree: never;
         toPrimaryKey: (data: unknown) => any;
         operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
         sortMode: never;
         filterMode: never;
         groupMode: never;
         pivotMode: never;
-        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
         groupRowsState: GroupRowsState<unknown>;
+        treeExpandState: TreeExpandState<any>;
+        treeExpandMode: never;
         multiSort: never;
         controlledSort: never;
         controlledFilter: never;
@@ -4567,10 +5561,19 @@ declare const useManagedDataSource: (props: unknown) => {
         livePagination: never;
         refetchKey: never;
         isRowSelected: never;
+        isNodeSelected: never;
+        isNodeExpanded: never;
+        isNodeCollapsed: never;
+        onNodeCollapse: never;
+        onNodeExpand: never;
         debugId: never;
+        debugMode: never;
+        nodesKey: string;
+        treeSelection: never;
         batchOperationDelay: never;
         onDataArrayChange: never;
         onDataMutations: never;
+        onTreeDataMutations: never;
         onReady: never;
         rowInfoReducers: never;
         lazyLoad: never;
@@ -4608,10 +5611,69 @@ declare type AggregationReducerResult<AggregationResultType extends any = any> =
  * you can use `isGroupRow: boolean` to discriminate between group rows vs normal rows.
  *
  */
-declare type InfiniteTableRowInfo<T> = InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T> | InfiniteTable_NoGrouping_RowInfoNormal<T>;
+declare type InfiniteTableRowInfo<T> = InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T> | InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_Tree_RowInfoLeafNode<T> | InfiniteTable_Tree_RowInfoParentNode<T>;
+declare type InfiniteTable_Tree_RowInfoLeafNode<T> = {
+    dataSourceHasGrouping: false;
+    isTreeNode: true;
+    isParentNode: false;
+    isGroupRow: false;
+    data: T;
+} & InfiniteTable_RowInfoBase<T> & InfiniteTable_Tree_RowInfoBase<T>;
+declare type InfiniteTable_Tree_RowInfoBase<T> = {
+    isTreeNode: true;
+    isParentNode: boolean;
+    indexInParent: number;
+    nodePath: any[];
+    parentNodes: InfiniteTable_Tree_RowInfoParentNode<T>[];
+    /**
+     * Available when using a tree data, this will be set for both parent and leaf nodes
+     * Italy  - country         - indexInParentGroups: [0]
+     *    Rome - city           - indexInParentGroups: [0,0]
+     *      Marco    - person   - indexInParentGroups: [0,0,0]
+     *      Luca     - person   - indexInParentGroups: [0,0,1]
+     *      Giuseppe  - person  - indexInParentGroups: [0,0,2]
+     * USA - country            - indexInParentGroups: [1]
+     *    LA - city             - indexInParentGroups: [1,0]
+     *      Bob  - person       - indexInParentGroups: [1,0,2]
+     */
+    indexInParentNodes: number[];
+    /**
+     * how many leaf nodes are under the current parent node.
+     * if this node is a leaf node, it will be 0,
+     * if this is a parent node, this will be the count of all the leaf nodes under this parent node (including the ones
+     * not visible due to collapsing).
+     */
+    totalLeafNodesCount: number;
+    /**
+     * The count of all leaf nodes (normal ) inside the parent node that are not being visible
+     * due to collapsing (either the current node is collapsed or any of its direct children)
+     */
+    collapsedLeafNodesCount: number;
+    treeNesting: number;
+    selfLoaded: boolean;
+};
+declare type InfiniteTable_Tree_RowInfoNode<T> = InfiniteTable_Tree_RowInfoLeafNode<T> | InfiniteTable_Tree_RowInfoParentNode<T>;
+declare type InfiniteTable_Tree_RowInfoParentNode<T> = {
+    dataSourceHasGrouping: false;
+    isParentNode: true;
+    isGroupRow: false;
+    nodeExpanded: boolean;
+    selfExpanded: boolean;
+    data: T;
+    selectedLeafNodesCount: number;
+    /**
+     * This array contains all the (uncollapsed, so visible) row infos under this group, at any level of nesting,
+     * in the order in which they are visible in the table
+     */
+    deepRowInfoArray: InfiniteTable_Tree_RowInfoNode<T>[];
+    deselectedLeafNodesCount: number;
+    duplicateOf?: InfiniteTable_Tree_RowInfoParentNode<T>['id'];
+} & InfiniteTable_RowInfoBase<T> & InfiniteTable_Tree_RowInfoBase<T>;
 declare type InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> = {
     data: T;
     isGroupRow: false;
+    isTreeNode: false;
+    isParentNode: false;
     rowActive: boolean;
     rowDetailState: false | 'expanded' | 'collapsed';
     rowInfo: InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoNormal<T>;
@@ -4620,18 +5682,48 @@ declare type InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> = {
     rawValue: any;
     rowSelected: boolean | null;
 };
+declare type InfiniteTableRowInfoDataDiscriminator_ParentNode<T> = {
+    data: T;
+    isGroupRow: false;
+    isTreeNode: true;
+    isParentNode: true;
+    nodeExpanded: boolean;
+    rowActive: boolean;
+    rowDetailState: false | 'expanded' | 'collapsed';
+    rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>;
+    field?: keyof T;
+    value: any;
+    rawValue: any;
+    rowSelected: boolean | null;
+};
+declare type InfiniteTableRowInfoDataDiscriminator_LeafNode<T> = {
+    data: T;
+    isGroupRow: false;
+    isTreeNode: true;
+    isParentNode: false;
+    nodeExpanded: boolean;
+    rowActive: boolean;
+    rowDetailState: false | 'expanded' | 'collapsed';
+    rowInfo: InfiniteTable_Tree_RowInfoLeafNode<T>;
+    field?: keyof T;
+    value: any;
+    rawValue: any;
+    rowSelected: boolean | null;
+};
 declare type InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> = {
     rowActive: boolean;
     data: Partial<T> | null;
     rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<T>;
     rowDetailState: false | 'expanded' | 'collapsed';
     isGroupRow: true;
+    isTreeNode: false;
     field?: keyof T;
     value: any;
     rawValue: any;
     rowSelected: boolean | null;
 };
-declare type InfiniteTableRowInfoDataDiscriminator<T> = InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> | InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T>;
+declare type InfiniteTableRowInfoDataDiscriminator<T> = InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> | InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> | InfiniteTableRowInfoDataDiscriminator_Node<T>;
+declare type InfiniteTableRowInfoDataDiscriminator_Node<T> = InfiniteTableRowInfoDataDiscriminator_ParentNode<T> | InfiniteTableRowInfoDataDiscriminator_LeafNode<T>;
 /**
  * This is the base row info for all scenarios - things every
  * rowInfo is guaranteed to have (be it group or normal row, or dataSource with or without grouping)
@@ -4648,14 +5740,17 @@ declare type InfiniteTable_RowInfoBase<_T> = {
 };
 declare type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
     dataSourceHasGrouping: true;
+    isTreeNode: false;
     data: T;
     isGroupRow: false;
 } & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
 declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
     dataSourceHasGrouping: true;
+    isTreeNode: false;
     data: Partial<T> | null;
     reducerData?: Partial<Record<keyof T, any>>;
     isGroupRow: true;
+    duplicateOf?: InfiniteTable_HasGrouping_RowInfoGroup<T>['id'];
     /**
      * This array contains all the (uncollapsed, so visible) row infos under this group, at any level of nesting,
      * in the order in which they are visible in the table
@@ -4732,6 +5827,7 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
 } & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
 declare type InfiniteTable_NoGrouping_RowInfoNormal<T> = {
     dataSourceHasGrouping: false;
+    isTreeNode: false;
     data: T;
     isGroupRow: false;
     selfLoaded: boolean;
@@ -4825,12 +5921,27 @@ declare type InfiniteTable_HasGrouping_RowInfoBase<T> = {
     selfLoaded: boolean;
 };
 declare type GroupKeyType<T extends any = any> = T;
+declare type TreeKeyType<T extends any = any> = T;
 declare type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
 declare type PivotGroupValueType<DataType, KeyType> = {
     reducerResults: PivotReducerResults<KeyType>;
     items: DataType[];
 };
 declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
+declare type DeepMapTreeValueType<DataType, _KeyType> = {
+    items: DataType[];
+    node: DataType | null;
+    reducerResults: Record<string, AggregationReducerResult>;
+    cache: boolean;
+    childrenLoading: boolean;
+    childrenAvailable: boolean;
+    treeNesting: number;
+    totalLeafNodesCount: number;
+    leavesAvailableCount: number;
+    isTree: true;
+    isGroupBy: false;
+    error?: string;
+};
 declare type DeepMapGroupValueType<DataType, KeyType> = {
     /**
      * These are leaf items. This array may be empty when there is batched lazy loading
@@ -4842,6 +5953,8 @@ declare type DeepMapGroupValueType<DataType, KeyType> = {
     totalChildrenCount?: number;
     cache: boolean;
     error?: string;
+    isTree: false;
+    isGroupBy: true;
     reducerResults: Record<string, AggregationReducerResult>;
     pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
 };
@@ -4869,6 +5982,7 @@ declare type DataGroupResult<DataType, KeyType extends any> = {
 };
 declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
 declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
+declare type InfiniteTablePropRepeatWrappedGroupRows<T> = boolean | ((rowInfo: InfiniteTableRowInfo<T>) => boolean);
 
 declare type InfiniteCheckBoxPropChecked = true | false | null;
 declare type InfiniteCheckBoxProps = {
@@ -4910,6 +6024,7 @@ declare type OverlayParams = {
 };
 declare type ElementContainerGetter = (() => HTMLElement | string | Promise<HTMLElement | string>) | string | HTMLElement | Promise<HTMLElement | string>;
 declare 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
@@ -4923,7 +6038,10 @@ declare type OverlayShowParams = {
     alignPosition: AlignPositionOptions['alignPosition'];
     alignTo: AdvancedAlignable | PointCoords;
 };
-declare type ShowOverlayFn = (content: ReactNode | (() => ReactNode), params: OverlayShowParams) => VoidFunction | undefined;
+declare type UpdateOverlayContentFn = (content: ReactNode | (() => ReactNode), options?: {
+    skipRealign?: boolean;
+}) => void;
+declare type ShowOverlayFn = (content: ReactNode | (() => ReactNode), params: OverlayShowParams) => UpdateOverlayContentFn;
 declare function useOverlay(params: OverlayParams): {
     portal: string | number | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | null | undefined;
     hideOverlay: (id: string) => void;
@@ -5403,6 +6521,7 @@ declare type InfiniteTablePropKeyboardShorcut = {
         stopNext: boolean;
     } | Promise<any>;
 };
+declare type InfiniteTablePropDebugMode = boolean;
 interface InfiniteTableProps<T> {
     debugId?: string;
     columns: InfiniteTablePropColumns<T>;
@@ -5411,7 +6530,9 @@ interface InfiniteTableProps<T> {
     loadingText?: Renderable;
     components?: InfiniteTablePropComponents<T>;
     wrapRowsHorizontally?: boolean;
+    debugMode?: InfiniteTablePropDebugMode;
     keyboardShortcuts?: InfiniteTablePropKeyboardShorcut[];
+    repeatWrappedGroupRows?: InfiniteTablePropRepeatWrappedGroupRows<T>;
     viewportReservedWidth?: number;
     onViewportReservedWidthChange?: (viewportReservedWidth: number) => void;
     showColumnFilters?: boolean;
@@ -5640,11 +6761,28 @@ declare function debounce(fn: Function, { wait }: {
     wait: number;
 }): (...args: any[]) => void;
 
+declare type ToPath<T> = (data: T) => string[];
+declare type ToTreeDataArrayOptions<T, RESULT_T> = {
+    nodesKey: keyof RESULT_T;
+    pathKey: keyof T | string | ToPath<T>;
+    emptyGroup?: object | ((path: string[], children: T[]) => object);
+};
+declare function toTreeDataArray<T = any, RESULT_T = any>(data: T[], options: ToTreeDataArrayOptions<T, RESULT_T>): RESULT_T[];
+
+declare function TreeDataSource<T>(props: TreeDataSourceProps<T>): React$1.JSX.Element;
+
+declare type TreeGridOnlyProps<_T> = {};
+declare type InfiniteTablePropsNotAvailableInTreeGrid = keyof Pick<InfiniteTableProps<any>, 'pivotColumns' | 'pivotColumnGroups' | 'pivotTotalColumnPosition' | 'pivotGrandTotalColumnPosition' | 'groupColumn' | 'groupRenderStrategy' | 'hideEmptyGroupColumns' | 'showSeparatePivotColumnForSingleAggregation' | 'isRowDetailExpanded' | 'isRowDetailEnabled' | 'rowDetailCache' | 'rowDetailState' | 'defaultRowDetailState' | 'onRowDetailStateChange' | 'rowDetailHeight' | 'rowDetailRenderer' | 'groupRenderStrategy'>;
+declare type TreeGridProps<T> = Omit<InfiniteTableProps<T>, InfiniteTablePropsNotAvailableInTreeGrid> & TreeGridOnlyProps<T>;
+
+declare function TreeGrid<T>(props: TreeGridProps<T>): React$1.JSX.Element;
+
 declare type DataSourceChildren<T> = React$1.ReactNode | ((values: DataSourceState<T>) => React$1.ReactNode);
 
-declare function useDataSourceInternal<T>(props: Omit<DataSourceProps<T>, 'children'>): {
+declare function useDataSourceInternal<T, PROPS_TYPE = DataSourceProps<T>>(props: Omit<PROPS_TYPE, 'children'>): {
     DataSource: ({ children }: {
         children: DataSourceChildren<T>;
+        nodesKey?: string | undefined;
     }) => React__default.JSX.Element;
     state: DataSourceState<T>;
 };
@@ -5786,4 +6924,4 @@ declare const components: {
     NumberFilterEditor: typeof NumberFilterEditor;
 };
 
-export { AdvancedAlignable, CellSelectionState, CellSelectionStateObject, ColumnTypeWithInherit, DataClient, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceApi, DataSourceCRUDParam, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceInsertParam, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourceMasterDetailContextValue, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropCellSelection_MultiCell, DataSourcePropCellSelection_SingleCell, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnCellSelectionChange_MultiCell, DataSourcePropOnCellSelectionChange_SingleCell, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropPivotBy, DataSourcePropRowInfoReducers, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropShouldReloadData, DataSourcePropShouldReloadDataObject, DataSourcePropSortFn, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourcePropsWithChildren, DataSourceRawReducer, DataSourceRemoteData, DataSourceRowInfoReducer, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, DebugLogger, DeepMap, ElementContainerGetter, FixedSizeSet, FlashingColumnCell, GroupRowsState, InfiniteColumnEditorContextType, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnApi, InfiniteTableColumnCellContextType, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderFunctionForGroupRows, InfiniteTableColumnRenderFunctionForNormalRows, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnValueFormatterParams, InfiniteTableColumnValueGetterParams, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroupVisibility, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropGetCellContextMenuItems, InfiniteTablePropGetColumnMenuItems, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropKeyboardShorcut, InfiniteTablePropMultiSortBehavior, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, InfiniteTable_HasGrouping_RowInfoGroup, InfiniteTable_HasGrouping_RowInfoNormal, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, Menu, MenuChildrenFnParam, MenuColumn, MenuColumnRenderParam, MenuDecoration, MenuIconProps, MenuItemActionContext, MenuItemDefinition, MenuItemObject, MenuProps, MenuRenderable, MenuRuntimeItem, MenuRuntimeItemSelectable, MenuSeparator, OverlayShowParams, RowDetailCache, RowDetailState, RowDetailStateObject, RowDisabledState, RowDisabledStateObject, RowSelectionState, ScrollStopInfo, Scrollbars, ShowOverlayFn, TableRenderRange, WeakFixedSizeSet, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, defaultFilterTypes as filterTypes, flatten, buildManagedComponent as getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, queryKeyToCacheKey, useManagedComponentState as useComponentState, useDataSourceInternal, useDataSourceState, useEffectWhen, useEffectWhenSameDeps, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes };
+export { AdvancedAlignable, CellSelectionState, CellSelectionStateObject, ColumnTypeWithInherit, DataClient, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceApi, DataSourceCRUDParam, DataSourceCallback_BaseParam, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceInsertParam, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourceMasterDetailContextValue, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropCellSelection_MultiCell, DataSourcePropCellSelection_SingleCell, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsNodeExpanded, DataSourcePropIsNodeSelected, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnCellSelectionChange_MultiCell, DataSourcePropOnCellSelectionChange_SingleCell, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropOnTreeSelectionChange, DataSourcePropOnTreeSelectionChange_MultiNode, DataSourcePropOnTreeSelectionChange_SingleNode, DataSourcePropPivotBy, DataSourcePropRowInfoReducers, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropShouldReloadData, DataSourcePropShouldReloadDataObject, DataSourcePropSortFn, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourcePropTreeSelection, DataSourcePropTreeSelection_MultiNode, DataSourcePropTreeSelection_SingleNode, DataSourceProps, DataSourcePropsNotAvailableInTreeDataSource, DataSourcePropsWithChildren, DataSourceRawReducer, DataSourceRemoteData, DataSourceRowInfoReducer, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, DataSourceUpdateParam, DebugLogger, DeepMap, ElementContainerGetter, FixedSizeSet, FlashingColumnCell, GroupRowsState, InfiniteColumnEditorContextType, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnApi, InfiniteTableColumnCellContextType, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderFunctionForGroupRows, InfiniteTableColumnRenderFunctionForNormalRows, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnValueFormatterParams, InfiniteTableColumnValueGetterParams, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroupVisibility, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropGetCellContextMenuItems, InfiniteTablePropGetColumnMenuItems, InfiniteTablePropGetContextMenuItems, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropKeyboardShorcut, InfiniteTablePropMultiSortBehavior, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTablePropsNotAvailableInTreeGrid, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, InfiniteTable_HasGrouping_RowInfoGroup, InfiniteTable_HasGrouping_RowInfoNormal, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, Menu, MenuChildrenFnParam, MenuColumn, MenuColumnRenderParam, MenuDecoration, MenuIconProps, MenuItemActionContext, MenuItemDefinition, MenuItemObject, MenuProps, MenuRenderable, MenuRuntimeItem, MenuRuntimeItemSelectable, MenuSeparator, OverlayShowParams, RowDetailCache, RowDetailState, RowDetailStateObject, RowDisabledState, RowDisabledStateObject, RowSelectionState, ScrollStopInfo, Scrollbars, ShowOverlayFn, TableRenderRange, TreeDataSource, TreeDataSourceProps, TreeExpandState, TreeExpandStateValue, TreeGrid, TreeGridOnlyProps, TreeGridProps, TreeSelectionState, TreeSelectionValue, UpdateOverlayContentFn, WeakFixedSizeSet, alignNode, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, defaultFilterTypes as filterTypes, flatten, buildManagedComponent as getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, multisortNested, queryKeyToCacheKey, toTreeDataArray, useManagedComponentState as useComponentState, useDataSourceInternal, useDataSourceState, useEffectWhen, useEffectWhenSameDeps, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useInfinitePortalContainer, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes };