import * as React$1 from 'react';
import React__default, { CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, KeyboardEvent, HTMLAttributes, ReactNode, EffectCallback, DependencyList } from 'react';

type ManagedComponentStateContextValue<T_STATE, T_ACTIONS> = {
    getComponentState: () => T_STATE;
    componentState: T_STATE;
    componentActions: T_ACTIONS;
    assignState: (state: Partial<T_STATE>) => void;
    replaceState: (state: T_STATE) => void;
};
type ComponentStateGeneratedActions<T_STATE> = {
    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
};
type ComponentInterceptedActions<T_STATE> = {
    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
        actions: ComponentStateGeneratedActions<T_STATE>;
        state: T_STATE;
    }) => void | boolean;
};
type ComponentMappedCallbacks<T_STATE> = {
    [k in keyof T_STATE]: (value: T_STATE[k], state: T_STATE) => {
        callbackName: string;
        callbackParams: any[];
    };
};
type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;

type NonUndefined<T> = T extends undefined ? never : T;

type ToPath<T> = (data: T) => string[];
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[];

type VoidFn$1 = () => void;
type Pair<KeyType, ValueType> = {
    value?: ValueType;
    map?: Map<KeyType, Pair<KeyType, ValueType>>;
    length: number;
    revision?: number;
};
type DeepMapVisitFn<KeyType, ValueType, ReturnType = void> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn$1) => ReturnType;
declare class DeepMap<KeyType, ValueType> {
    private map;
    private length;
    private revision;
    private emptyKey;
    static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): 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][];
    getUnnestedKeysStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): KeyType[][];
    getKeysStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): KeyType[][];
    private getStartingWith;
    private getMapAt;
    getAllChildrenSizeFor(keys: KeyType[]): number;
    getDirectChildrenSizeFor(keys: KeyType[]): number;
    set(keys: KeyType[] & {
        length: Omit<number, 0>;
    }, value: ValueType): this;
    get(keys: KeyType[]): ValueType | undefined;
    get size(): number;
    clear(): void;
    delete(keys: KeyType[]): boolean;
    has(keys: KeyType[]): boolean;
    private visitKey;
    visit: (fn: DeepMapVisitFn<KeyType, ValueType>) => void;
    visitSome: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn$1) => boolean) => void;
    visitDepthFirst: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn$1) => void) => void;
    private visitWithNext;
    private getArray;
    rawKeysAt(keys: KeyType[]): KeyType[];
    valuesAt(keys: KeyType[]): ValueType[];
    values(): Generator<ValueType, void, unknown>;
    keys(): Generator<KeyType[], void, unknown>;
    entries(): Generator<[KeyType[], ValueType], void, unknown>;
    topDownEntries(): [KeyType[], ValueType][];
    topDownKeys(): KeyType[][];
    topDownValues(): ValueType[];
    private sortedIterator;
}

type NodePath$1<PRIMARY_KEY_TYPE = any> = PRIMARY_KEY_TYPE[];
type TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE = any> = {
    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
    defaultExpanded: boolean;
    collapsedIds?: never;
    expandedIds?: never;
} | {
    defaultExpanded: true;
    collapsedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
    expandedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
    collapsedIds?: never;
    expandedIds?: never;
} | {
    defaultExpanded: false;
    collapsedPaths?: NodePath$1<PRIMARY_KEY_TYPE>[];
    expandedPaths: NodePath$1<PRIMARY_KEY_TYPE>[];
    collapsedIds?: never;
    expandedIds?: never;
};
type TreeExpandStateObject_ById<PRIMARY_KEY_TYPE = any> = {
    defaultExpanded: boolean;
    expandedIds: PRIMARY_KEY_TYPE[];
    collapsedIds: PRIMARY_KEY_TYPE[];
    expandedPaths?: never;
    collapsedPaths?: never;
} | {
    defaultExpanded: true;
    collapsedIds: PRIMARY_KEY_TYPE[];
    expandedIds?: PRIMARY_KEY_TYPE[];
    expandedPaths?: never;
    collapsedPaths?: never;
} | {
    defaultExpanded: false;
    collapsedIds?: PRIMARY_KEY_TYPE[];
    expandedIds: PRIMARY_KEY_TYPE[];
    expandedPaths?: never;
    collapsedPaths?: never;
};
type TreeExpandStateObject<PRIMARY_KEY_TYPE = any> = TreeExpandStateObject_ByPath<PRIMARY_KEY_TYPE> | TreeExpandStateObject_ById<PRIMARY_KEY_TYPE>;
type TreeExpandStateMode = 'id' | 'path';
declare class TreeExpandState<PRIMARY_KEY_TYPE = any> {
    collapsedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
    expandedPathsMap: DeepMap<PRIMARY_KEY_TYPE, true>;
    collapsedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
    expandedIdsMap: Map<PRIMARY_KEY_TYPE, true>;
    private _mode;
    get mode(): TreeExpandStateMode;
    defaultExpanded: boolean;
    constructor(clone?: TreeExpandStateObject | TreeExpandState);
    reset(): void;
    destroy(): void;
    expandAll: () => void;
    collapseAll: () => void;
    expandNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
    collapseNode(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): void;
    setNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>, expanded: boolean): void;
    isNodeExpandedByPath(nodePath: NodePath$1<PRIMARY_KEY_TYPE>): boolean;
    isNodeExpandedById(id: PRIMARY_KEY_TYPE): boolean;
    isNodeExpanded(nodePathOrId: PRIMARY_KEY_TYPE | NodePath$1<PRIMARY_KEY_TYPE>): boolean;
    update(stateObject: TreeExpandStateObject): void;
    getState(): TreeExpandStateObject;
}

type OnNodeStateChangeParam = DataSourceCallback_BaseParam<any> & {};
type TreeDataSourceOnlyProps<T> = {
    nodesKey?: string;
    treeSelection?: DataSourcePropTreeSelection;
    treeFilterFunction?: DataSourcePropTreeFilterFunction<T>;
    defaultTreeSelection?: DataSourcePropTreeSelection;
    treeExpandState?: TreeExpandStateValue;
    defaultTreeExpandState?: TreeExpandStateValue;
    onTreeExpandStateChange?: (treeExpandState: TreeExpandStateObject<any>, params: {
        dataSourceApi: DataSourceApi<T>;
        nodePath: NodePath$1 | null;
        nodeState: 'collapsed' | 'expanded';
    }) => void;
    onTreeDataMutations?: ({ dataArray, timestamp, treeMutations, nodesKey, }: {
        nodesKey: keyof T | any;
        dataArray: DataSourceState<T>['originalDataArray'];
        timestamp: number;
        treeMutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['treeMutations']>;
    }) => void;
    isNodeSelected?: DataSourcePropIsNodeSelected<T>;
    isNodeSelectable?: DataSourcePropIsNodeSelectable<T>;
    isNodeReadOnly?: DataSourcePropIsNodeReadOnly<T>;
    /**
     * Called when a node is expanded. Not called when treeApi.expandAll is called.
     */
    onNodeExpand?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
    /**
     * Called when a node is collapsed. Not called when treeApi.collapseAll is called.
     */
    onNodeCollapse?: (node: NodePath$1, param: OnNodeStateChangeParam) => void;
} & ({
    selectionMode?: 'multi-row';
    treeSelection?: DataSourcePropTreeSelection_MultiNode;
    defaultTreeSelection?: DataSourcePropTreeSelection_MultiNode;
    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_MultiNode;
} | {
    selectionMode?: 'single-row';
    treeSelection?: DataSourcePropTreeSelection_SingleNode;
    defaultTreeSelection?: DataSourcePropTreeSelection_SingleNode;
    onTreeSelectionChange?: DataSourcePropOnTreeSelectionChange_SingleNode;
} | {
    selectionMode?: 'single-cell';
    cellSelection?: DataSourcePropCellSelection_SingleCell;
    defaultCellSelection?: DataSourcePropCellSelection_SingleCell;
    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_SingleCell;
} | {
    selectionMode?: 'multi-cell';
    cellSelection?: DataSourcePropCellSelection_MultiCell;
    defaultCellSelection?: DataSourcePropCellSelection_MultiCell;
    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_MultiCell;
} | {
    selectionMode?: false;
}) & ({
    isNodeCollapsed?: DataSourcePropIsNodeExpanded<T>;
    isNodeExpanded?: never;
} | {
    isNodeExpanded?: DataSourcePropIsNodeExpanded<T>;
    isNodeCollapsed?: never;
});
type DataSourcePropsNotAvailableInTreeDataSource = keyof Pick<DataSourceProps<any>, 'groupBy' | 'defaultGroupBy' | 'nodesKey' | 'defaultGroupRowsState' | 'groupRowsState' | 'onGroupRowsStateChange' | 'onGroupByChange' | 'collapseGroupRowsOnDataFunctionChange' | 'livePagination' | 'onLivePaginationCursorChange' | 'groupMode' | 'filterFunction' | 'onPivotByChange' | 'pivotBy' | 'defaultPivotBy' | 'selectionMode' | 'rowSelection' | 'defaultRowSelection'>;
type TreeDataSourceProps<T> = Omit<DataSourceProps<T>, DataSourcePropsNotAvailableInTreeDataSource> & TreeDataSourceOnlyProps<T>;

declare function TreeDataSource<T>(props: TreeDataSourceProps<T>): React$1.JSX.Element;

type NodePath = any[];
type TreeSelectionStateObject = {
    selectedPaths: NodePath;
    deselectedPaths: NodePath;
    defaultSelection: boolean;
} | {
    defaultSelection: true;
    deselectedPaths: NodePath;
    selectedPaths?: NodePath;
} | {
    defaultSelection: false;
    selectedPaths: NodePath;
    deselectedPaths?: NodePath;
};
type TreeSelectionStateConfig<_T = any> = {
    treeDeepMap: DeepMap<any, DeepMapTreeValueType<any, any>>;
};
type GetTreeSelectionStateConfig<T> = () => TreeSelectionStateConfig<T>;
type NodeSelectionState = {
    selected: boolean | null;
    selectedCount: number;
    deselectedCount: number;
    leafCount: number;
};
declare class TreeSelectionState<T = any> {
    selectedPaths: NodePath[] | null;
    deselectedPaths: NodePath[] | null;
    defaultSelection: boolean;
    selectionMap: DeepMap<NodePath, boolean>;
    cache: DeepMap<NodePath, NodeSelectionState>;
    getConfig: GetTreeSelectionStateConfig<T>;
    getTreeDeepMap(): DeepMap<any, DeepMapTreeValueType<any, any>>;
    isLeafNode(nodePath: NodePath): boolean;
    getLeafNodesCount(nodePath: NodePath): number;
    static from<T>(treeSelectionState: TreeSelectionStateObject, getConfig: GetTreeSelectionStateConfig<T>): TreeSelectionState<T>;
    constructor(state: TreeSelectionStateObject | TreeSelectionState, getConfig: GetTreeSelectionStateConfig<T>);
    setConfigFn(getConfig: GetTreeSelectionStateConfig<T>): void;
    xcache(): void;
    update(stateObject: TreeSelectionStateObject): void;
    setSelectionForPath(nodePath: NodePath, selected: boolean): void;
    getState(): TreeSelectionStateObject;
    deselectAll(): void;
    selectAll(): void;
    isNodeSelected(nodePath: NodePath): boolean | null;
    private isSelfSelected;
    private cacheIt;
    private getSelectionStateForNode;
    private isPathSelected;
    private getNodeBooleanSelectionStateFromParent;
    setNodeSelection(nodePath: NodePath, selected: boolean): void;
    selectNode(nodePath: NodePath): void;
    deselectNode(nodePath: any[]): void;
    toggleNodeSelection(nodePath: NodePath): void;
    getSelectedCount(): number;
    getDeselectedCount(): number;
    getSelectionCountFor(nodePath?: NodePath): {
        selectedCount: number;
        deselectedCount: number;
    };
    destroy(): void;
}

type TreeGridOnlyProps<_T> = {};
type InfiniteTablePropsNotAvailableInTreeGrid = keyof Pick<InfiniteTableProps<any>, 'pivotColumns' | 'pivotColumnGroups' | 'pivotTotalColumnPosition' | 'pivotGrandTotalColumnPosition' | 'groupColumn' | 'groupRenderStrategy' | 'hideEmptyGroupColumns' | 'showSeparatePivotColumnForSingleAggregation' | 'isRowDetailExpanded' | 'isRowDetailEnabled' | 'rowDetailCache' | 'rowDetailState' | 'defaultRowDetailState' | 'onRowDetailStateChange' | 'rowDetailHeight' | 'rowDetailRenderer' | 'groupRenderStrategy'>;
type TreeGridProps<T> = Omit<InfiniteTableProps<T>, InfiniteTablePropsNotAvailableInTreeGrid> & TreeGridOnlyProps<T>;

declare function TreeGrid<T>(props: TreeGridProps<T>): React$1.JSX.Element;

type DebugLogger = {
    (...args: any[]): void;
    extend: (channelName: string) => DebugLogger;
    color: (colorName: string, ...message: string[]) => [string, string];
    enabled: boolean;
    channel: string;
    destroy: () => void;
    logFn: undefined | ((...args: any[]) => void);
};
declare const debug: {
    (channelName: string): DebugLogger;
    colors: string[];
    enable: string;
    diffenable: string | boolean;
    logFn: DebugLogger["logFn"];
    destroyAll: () => void;
    onLogIntent: (channel: string, fn: (options: {
        timestamp: number;
        channel: string;
        color: string;
        args: any[];
    }) => void) => VoidFunction;
};

interface LogFn {
    (...args: any[]): void;
    extend: (channelName: string) => LogFn;
}
declare class Logger {
    debug: LogFn;
    error: LogFn;
    constructor(channelName: string);
}

interface Size {
    width: number;
    height: number;
}

interface ScrollPosition {
    scrollTop: number;
    scrollLeft: number;
}
type OnScrollFn = (scrollPosition: ScrollPosition) => void;

type RenderRange = {
    renderStartIndex: number;
    renderEndIndex: number;
};

type VoidFn = () => void;

type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
interface SubscriptionCallback<T> {
    (node: T, callback?: () => void): void;
    get: () => T | null;
    destroy: VoidFn;
    onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
    getListenersCount: () => number;
}

type DataSourceMutation<T> = {
    type: 'delete';
    primaryKey: any;
    nodePath?: never;
    originalData: T;
    metadata: any;
} | {
    type: 'delete';
    primaryKey?: never;
    nodePath: NodePath$1;
    originalData: T;
    metadata: any;
} | {
    type: 'update';
    primaryKey: any;
    nodePath?: never;
    data: Partial<T>;
    originalData: T;
    metadata: any;
} | {
    type: 'update';
    primaryKey?: never;
    nodePath: NodePath$1;
    data: Partial<T>;
    originalData: T;
    metadata: any;
} | {
    type: 'update-children';
    primaryKey?: never;
    nodePath: NodePath$1;
    children: UpdateChildrenFn<T>;
    originalData: T;
    metadata: any;
} | {
    type: 'insert';
    primaryKey: any;
    nodePath?: never;
    position: 'before' | 'after';
    originalData: null;
    data: T;
    metadata: any;
} | {
    type: 'insert';
    primaryKey?: never;
    nodePath: NodePath$1;
    position: 'before' | 'after';
    originalData: null;
    data: T;
    metadata: any;
} | {
    type: 'clear-all';
    primaryKey: undefined;
    metadata: any;
};
declare class DataSourceCache<DataType, PrimaryKeyType = string> {
    private affectedFields;
    private allFieldsAffected;
    private nodesKey;
    private primaryKeyToData;
    private nodePathToData;
    constructor(options: {
        nodesKey: string | undefined;
    });
    static clone<DataType, PrimaryKeyType = string>(cache: DataSourceCache<DataType, PrimaryKeyType>, { light }?: {
        light?: boolean;
    }): DataSourceCache<DataType, PrimaryKeyType>;
    getAffectedFields: () => true | Set<keyof DataType>;
    delete: (primaryKey: PrimaryKeyType, originalData: DataType, metadata: any) => void;
    deleteNodePath: (nodePath: NodePath$1, originalData: DataType, metadata: any) => void;
    insert: (primaryKey: PrimaryKeyType, data: DataType, position: "before" | "after", metadata: any) => void;
    insertNodePath: (nodePath: NodePath$1, data: DataType, position: "before" | "after", metadata: any) => void;
    update: (primaryKey: PrimaryKeyType, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
    updateNodePath: (nodePath: NodePath$1, data: Partial<DataType>, originalData: DataType, metadata: any) => void;
    updateChildren: (nodePath: NodePath$1, children: UpdateChildrenFn<DataType>, originalData: DataType, metadata: any) => void;
    resetDataSource: (metadata: any) => void;
    shouldResetDataSource: () => boolean;
    clear: () => void;
    isEmpty: () => boolean;
    removeInfo: (primaryKey: PrimaryKeyType) => void;
    removeNodePathInfo: (nodePath: NodePath$1) => void;
    getMutationsForPrimaryKey: (primaryKey: PrimaryKeyType) => DataSourceMutation<DataType>[] | undefined;
    getMutationsForNodePath: (nodePath: NodePath$1) => DataSourceMutation<DataType>[] | undefined;
    getMutationsCount: () => number;
    getMutations: () => Map<PrimaryKeyType, DataSourceMutation<DataType>[]>;
    getTreeMutations: () => DeepMap<NodePath$1, DataSourceMutation<DataType>[]>;
    getMutationsArray: () => DataSourceMutation<DataType>[];
    getTreeMutationsArray: () => DataSourceMutation<DataType>[];
}

type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT, COMPONENT_SETUP_STATE> = {
    [propName in keyof TYPE_PROPS & keyof TYPE_RESULT]: 1 | ((value: TYPE_PROPS[propName], setupState: COMPONENT_SETUP_STATE) => TYPE_RESULT[propName]);
};
type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
    debugName?: string | ((props: T_PROPS) => string);
    initSetupState?: (props: T_PROPS) => COMPONENT_SETUP_STATE;
    layoutEffect?: boolean;
    forwardProps?: (setupState: COMPONENT_SETUP_STATE, props: T_PROPS) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE>;
    allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
    interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
    mappedCallbacks?: ComponentMappedCallbacks<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
    onPropChange?: (params: {
        name: keyof T_PROPS;
        oldValue: any;
        newValue: any;
    }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>, state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>) => void;
    onPropsChange?: (newPropValues: {
        [k in keyof T_PROPS]?: {
            newValue: T_PROPS[k];
            oldValue: T_PROPS[k];
        };
    }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>, state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>) => void;
    mapPropsToState?: (params: {
        props: T_PROPS;
        state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>;
        oldState: null | (COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>);
        parentState: T_PARENT_STATE | null;
    }) => COMPONENT_DERIVED_STATE;
    concludeReducer?: (params: {
        previousState: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
        state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
        updatedProps: Partial<T_PROPS> | null;
        parentState: T_PARENT_STATE | null;
    }) => COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE;
    getReducerActions?: (dispatch: React$1.Dispatch<any>) => T_ACTIONS;
    getParentState?: () => T_PARENT_STATE;
    cleanup?: (state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & COMPONENT_DERIVED_STATE) => void;
    onControlledPropertyChange?: (name: string, newValue: any, oldValue: any) => void | ((value: any, oldValue: any) => any);
};
declare function buildManagedComponent<T_PROPS extends object, COMPONENT_MAPPED_STATE extends object, COMPONENT_SETUP_STATE extends object = {}, COMPONENT_DERIVED_STATE extends object = {}, T_ACTIONS = {}, T_PARENT_STATE = {}>(config: ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE, COMPONENT_DERIVED_STATE, T_ACTIONS, T_PARENT_STATE>): {
    ManagedComponentContextProvider: React$1.NamedExoticComponent<T_PROPS & {
        children: React$1.ReactNode;
    }>;
    useManagedComponent: (props: T_PROPS) => {
        contextValue: {
            componentState: COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE;
            componentActions: ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
            getComponentState: () => COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE;
            replaceState: (newState: COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE) => void;
            assignState: (newState: Partial<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>) => void;
        };
        ContextComponent: React$1.Context<ManagedComponentStateContextValue<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE, ComponentStateGeneratedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>>>;
    };
};
declare function useManagedComponentState<COMPONENT_STATE>(): ManagedComponentStateContextValue<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;

type Renderable = React$1.ReactNode | React$1.JSX.Element;

type TableRenderRange = {
    start: [number, number];
    end: [number, number];
    rowFixed?: FixedPosition;
    colFixed?: FixedPosition;
};
type FixedPosition = false | 'start' | 'end';
type WhichDirection = {
    horizontal?: boolean;
    vertical?: boolean;
};
type ItemSizeFunction = (index: number) => number;
interface IBrain {
    getColCount: () => number;
    getRowCount: () => number;
    getFixedCellInfo: () => {
        fixedRowsStart: number;
        fixedColsStart: number;
        fixedRowsEnd: number;
        fixedColsEnd: number;
    };
    getRowspanParent: (rowIndex: number, colIndex: number) => number;
    getColspanParent: (rowIndex: number, colIndex: number) => number;
    getRowHeight: (rowIndex: number) => number;
    getColWidth: (colIndex: number) => number;
    getRowHeightWithSpan: (rowIndex: number, colIndex: number, rowspan: number) => number;
    getColWidthWithSpan: (rowIndex: number, colIndex: number, colspan: number) => number;
    isRowFixedStart: (rowIndex: number) => boolean;
    isRowFixedEnd: (rowIndex: number) => boolean;
    getScrollPosition: () => ScrollPosition;
    getItemOffsetFor: (itemIndex: number, direction: 'horizontal' | 'vertical') => number;
    getItemSize: (itemIndex: number, direction: 'horizontal' | 'vertical') => number;
    getItemAt: (scrollPos: number, direction: 'horizontal' | 'vertical') => number;
    getAvailableSize: () => Size;
    getFixedStartRowsHeight: () => number;
    getFixedEndRowsHeight: (options?: {
        skipScroll: boolean;
    }) => number;
    getFixedStartColsWidth: () => number;
    getFixedEndColsWidth: (options?: {
        skipScroll: boolean;
    }) => number;
    getFixedEndColsOffsets: (options?: {
        skipScroll: boolean;
    }) => number[];
    getFixedEndRowsOffsets: (options?: {
        skipScroll: boolean;
    }) => number[];
    isRowFixed: (rowIndex: number) => boolean;
    isColFixed: (colIndex: number) => boolean;
    getRenderRange: () => TableRenderRange;
    getExtraSpanCellsForRange: (options: {
        horizontal: {
            startIndex: number;
            endIndex: number;
        };
        vertical: {
            startIndex: number;
            endIndex: number;
        };
    }) => [number, number][];
    getRowspan: (rowIndex: number, colIndex: number) => number;
    getColspan: (rowIndex: number, colIndex: number) => number;
    getCellOffset: (rowIndex: number, colIndex: number) => {
        x: number;
        y: number;
    };
    name: string;
    onRenderRangeChange: (fn: (renderRange: TableRenderRange) => void) => VoidFunction;
    onScroll: (fn: OnScrollFn) => VoidFunction;
    onAvailableSizeChange: (fn: (size: Size) => void) => VoidFunction;
    onDestroy: (fn: VoidFunction) => void;
    onScrollStart: (fn: VoidFunction) => VoidFunction;
    onScrollStop: (fn: (scrollPos: ScrollPosition) => void) => VoidFunction;
}

type SpanFunction = ({ rowIndex, colIndex, }: {
    rowIndex: number;
    colIndex: number;
}) => number;
type RenderRangeType = {
    startIndex: number;
    endIndex: number;
};
type MatrixBrainOptions = {
    width: number;
    height: number;
    cols: number;
    rows: number;
    rowHeight: number | ItemSizeFunction;
    colWidth: number | ItemSizeFunction;
    rowspan?: SpanFunction;
    colspan?: SpanFunction;
};

type FnOnRenderRangeChange = (range: TableRenderRange) => void;
type FnOnDirectionalRenderRangeChange = (range: [number, number]) => void;
type FnOnRenderCountChange = ({ horizontal, vertical, }: {
    horizontal: number;
    vertical: number;
}) => void;
type OnAvailableSizeChange = (size: Size) => void;
type ShouldUpdateRenderCountOptions = {
    horizontalChange: boolean;
    colsChanged: boolean;
    colWidthChanged: boolean;
    widthChanged: boolean;
    colspanChanged: boolean;
    verticalChange: boolean;
    rowsChanged: boolean;
    rowHeightChanged: boolean;
    heightChanged: boolean;
    rowspanChanged: boolean;
};
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;
    name: string;
    protected availableHeight: MatrixBrainOptions['height'];
    protected availableRenderHeight: number;
    protected cols: MatrixBrainOptions['cols'];
    protected rows: MatrixBrainOptions['rows'];
    protected alwaysRenderedColumns: Set<number>;
    /**
     * This is only here for easier accessing in the renderer, when the horizontal layout is enabled.
     * In this way, the API is the same for both brains, so we don't have to cast the brain type in the renderer.
     */
    set rowsPerPage(rowsPerPage: number);
    get rowsPerPage(): number;
    protected _rowsPerPage: number;
    protected rowHeight: MatrixBrainOptions['rowHeight'];
    protected colWidth: MatrixBrainOptions['colWidth'];
    private rowspan;
    private colspan;
    private rowspanParent;
    private rowspanValue;
    protected rowHeightCache: number[];
    protected rowOffsetCache: number[];
    private verticalTotalSize;
    private colspanParent;
    private colspanValue;
    protected colWidthCache: number[];
    protected colOffsetCache: number[];
    private horizontalTotalSize;
    private horizontalRenderCount?;
    private verticalRenderCount?;
    protected maxHorizontalRenderCount: number;
    protected maxVerticalRenderCount: number;
    private horizontalExtendRangeBy;
    private verticalExtendRangeBy;
    protected horizontalRenderRange: RenderRangeType;
    protected verticalRenderRange: RenderRangeType;
    protected extraSpanCells: [number, number][];
    private scrollPosition;
    private onScrollFns;
    private onRenderRangeChangeFns;
    private onVerticalRenderRangeChangeFns;
    private onHorizontalRenderRangeChangeFns;
    private onDestroyFns;
    protected destroyed: boolean;
    private onRenderCountChangeFns;
    private onAvailableSizeChangeFns;
    private onScrollStartFns;
    private onScrollStopFns;
    private scrollTimeoutId;
    private scrollStopDelay;
    /**
     * Number of columns that are fixed at the start
     */
    private fixedColsStart;
    /**
     * Number of columns that are fixed at the end
     */
    private fixedColsEnd;
    /**
     * Number of rows that are fixed at the start
     */
    private fixedRowsStart;
    /**
     * Number of rows that are fixed at the end
     */
    private fixedRowsEnd;
    constructor(name: string);
    private reset;
    private resetVertical;
    private resetHorizontal;
    setScrollStopDelay: (scrollStopDelay: number) => void;
    getVirtualColIndex(colIndex: number, _opts?: {
        pageIndex: number;
    }): number;
    getRowCount: () => number;
    getColCount: () => number;
    update(options: Partial<MatrixBrainOptions>, shouldUpdateRenderCount?: (options: ShouldUpdateRenderCountOptions) => boolean): void;
    /**
     *
     * @param options.left - if true, extends the left side with the amount of current visible columns, otherwise with the specified number
     * @param options.right - if true, extends the right side with the amount of current visible columns, otherwise with the specified number
     */
    extendRenderRange(options: {
        start?: number | boolean;
        end?: number | boolean;
        direction: 'horizontal' | 'vertical';
    }): () => void;
    updateRenderCount(which?: WhichDirection): void;
    protected doUpdateRenderCount(which?: WhichDirection): void;
    get scrollTopMax(): number;
    get scrollLeftMax(): number;
    private setScrolling;
    private notifyScrollStart;
    private notifyScrollStop;
    setScrollPosition(scrollPosition: ScrollPosition, callback?: (scrollPos: ScrollPosition) => void): void;
    protected notifyAvailableSizeChange: () => void;
    protected notifyRenderRangeChange(immediate?: boolean): void;
    protected notifyVerticalRenderRangeChange: (immediate?: boolean) => void;
    protected notifyHorizontalRenderRangeChange: (immediate?: boolean) => void;
    private notifyScrollChange;
    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;
    isColFixedEnd: (colIndex: number) => boolean;
    isColFixedStart: (colIndex: number) => boolean;
    isRowFixedEnd: (rowIndex: number) => boolean;
    isRowFixedStart: (rowIndex: number) => boolean;
    isColFixed: (colIndex: number) => boolean;
    isRowFixed: (rowIndex: number) => boolean;
    getFixedEndColsWidth: () => number;
    /**
     * Returns an array of offsets for all cols fixed at the end
     *
     * The order in the array is from leftmost col to the rightmost col
     * The reference for offset is the left side of the table.
     * The offsets take into account the scroll position and return the correct position.
     *
     * The indexes in the returned array are the absolute indexes of the cols, so the returned array is an array with holes
     *
     */
    getFixedEndColsOffsets: ({ skipScroll }?: {
        skipScroll: boolean;
    }) => number[];
    /**
     * Returns an array of offsets for all rows fixed at the end
     *
     * The order in the array is from topmost row to the bottom-most row
     * The reference for offset is the top side of the table.
     * The offsets take into account the scroll position and return the correct position.
     *
     * The indexes in the returned array are the absolute indexes of the rows, so the returned array is an array with holes
     *
     */
    getFixedEndRowsOffsets: ({ skipScroll }?: {
        skipScroll: boolean;
    }) => number[];
    getFixedStartColsWidth: () => number;
    getFixedEndRowsHeight: () => number;
    getFixedStartRowsHeight: () => number;
    computeRenderCount: (which?: WhichDirection) => {
        horizontal: number;
        vertical: number;
    };
    setRenderCount: ({ horizontal, vertical, }: {
        horizontal: number | undefined;
        vertical: number | undefined;
    }) => void;
    private notifyRenderCountChange;
    updateFixedCells: (config: {
        fixedColsStart?: number;
        fixedColsEnd?: number;
        fixedRowsStart?: number;
        fixedRowsEnd?: number;
    }) => void;
    getFixedCellInfo: () => {
        fixedRowsStart: number;
        fixedColsStart: number;
        fixedRowsEnd: number;
        fixedColsEnd: number;
    };
    updateRenderRange: (which?: WhichDirection) => void;
    getExtraSpanCellsForRange: ({ horizontal, vertical, }: {
        horizontal: RenderRangeType;
        vertical: RenderRangeType;
    }) => [number, number][];
    computeRenderRange: (which?: WhichDirection) => {
        horizontal: RenderRangeType;
        vertical: RenderRangeType;
        extraCells: [number, number][];
    };
    computeDirectionalRenderRange: (direction: "horizontal" | "vertical") => {
        startIndex: number;
        endIndex: number;
    };
    getItemAt: (scrollPos: number, direction: "horizontal" | "vertical") => number;
    getCellOffset(rowIndex: number, colIndex: number): {
        x: number;
        y: number;
    };
    getInitialRowHeight(): number | ItemSizeFunction;
    getInitialCols(): number;
    getInitialRows(): number;
    getItemOffsetFor(itemIndex: number, direction: 'horizontal' | 'vertical'): number;
    protected computeCacheFor: (itemIndex: number, direction: "horizontal" | "vertical") => void;
    private getItemSizeCacheFor;
    private computeItemSpanUpTo;
    private getCellSpan;
    getRowspan: (rowIndex: number, colIndex: number) => number;
    getColspan: (rowIndex: number, colIndex: number) => number;
    getRowspanParent: (rowIndex: number, colIndex: number) => number;
    getColspanParent: (rowIndex: number, colIndex: number) => number;
    getItemSpanParent: (rowIndex: number, colIndex: number, direction: "horizontal" | "vertical") => number;
    getRowHeightWithSpan: (rowIndex: number, colIndex: number, rowspan: number) => number;
    getColWidthWithSpan: (rowIndex: number, colIndex: number, colspan: number) => number;
    private getItemSizeWithSpan;
    getRowHeight: (rowIndex: number) => number;
    getColWidth: (colIndex: number) => number;
    /**
     * For now, this doesn't take into account the row/colspan, and it's okay not to
     * @param itemIndex
     * @returns the size of the specified item
     */
    getItemSize: (itemIndex: number, direction: "horizontal" | "vertical") => number;
    getRowIndexInPage(rowIndex: number): number;
    getPageIndexForRow(_rowIndex: number): number;
    getVirtualizedContentSize(): {
        height: number;
        width: number;
    };
    getVirtualizedContentSizeFor(direction: 'horizontal' | 'vertical'): number;
    keepColumnRendered: (colIndex: number) => () => void;
    getAlwaysRenderedColumns: () => number[];
    setRenderRange: ({ horizontal, vertical, extraCells, }: {
        horizontal: RenderRangeType;
        vertical: RenderRangeType;
        extraCells?: [number, number][];
    }) => void;
    getRenderRangeCellCount: (range: TableRenderRange) => number;
    getMaxCellCount: () => number;
    getExtraCells: () => [number, number][];
    getScrollPosition: () => ScrollPosition;
    getRenderRange: () => TableRenderRange;
    onScroll: (fn: OnScrollFn) => () => void;
    onScrollStart: (fn: VoidFunction) => () => void;
    onScrollStop: (fn: (scrollPos: ScrollPosition) => void) => () => void;
    onRenderRangeChange: (fn: FnOnRenderRangeChange) => () => void;
    onVerticalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
    onHorizontalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
    onRenderCountChange: (fn: FnOnRenderCountChange) => () => void;
    onAvailableSizeChange: (fn: OnAvailableSizeChange) => () => void;
    onDestroy: (fn: VoidFn) => () => void;
    getAvailableSize: () => {
        width: number;
        height: number;
    };
    protected getAvailableRenderSize: () => {
        width: number;
        height: number;
    };
    private notifyDestroy;
    destroy(): void;
}

type CellSelectionPosition<ROW_PRIMARY_KEY_TYPE = any, COL_ID = string> = [ROW_PRIMARY_KEY_TYPE, COL_ID];
type CellSelectionStateObject = {
    selectedCells: CellSelectionPosition[];
    deselectedCells: CellSelectionPosition[];
    defaultSelection: boolean;
} | {
    defaultSelection: true;
    deselectedCells: CellSelectionPosition[];
    selectedCells?: CellSelectionPosition[];
} | {
    defaultSelection: false;
    selectedCells: CellSelectionPosition[];
    deselectedCells?: CellSelectionPosition[];
};
declare class CellSelectionState {
    wildcard: string;
    cache: DeepMap<any, boolean>;
    selectedRowsToColumns: Map<any, Set<string>>;
    selectedColumnsToRows: Map<string, Set<any>>;
    deselectedRowsToColumns: Map<any, Set<string>>;
    deselectedColumnsToRows: Map<string, Set<any>>;
    defaultSelection: boolean;
    debugId: string;
    constructor(clone?: CellSelectionStateObject | CellSelectionState);
    deselectAll: () => void;
    selectAll: () => void;
    selectCell(rowId: any, colId: string): void;
    deselectCell(rowId: any, colId: string): void;
    selectColumn(colId: string): void;
    deselectColumn(colId: string): void;
    setCellSelected(rowId: any, colId: string, selected: boolean): void;
    private setCellInDeselection;
    private setCellInSelection;
    update(stateObject: CellSelectionStateObject): void;
    /**
     * Returns whether there is at least one selected cell in the row
     *
     * @param rowId the row id
     * @param columnIds the columns currently available in the grid
     * @returns boolean
     */
    isCellSelectionInRow(rowId: any, columnIds: string[]): boolean;
    private error;
    isCellSelected(rowId: any, colId: string): boolean;
    private isCellSelected_Internal;
    getState(): CellSelectionStateObject;
}

type PointCoords = {
    top: number;
    left: number;
};

interface RowDetailCacheStorage<_K, T> {
    add(key: any, value: T): void;
    get(key: any): T | undefined;
    delete(key: any): void;
    has(key: any): boolean;
}
interface RowDetailCacheStorageForCurrentRow<T = RowDetailCacheEntry> {
    add(value: T): void;
    get(): T | undefined;
    delete(): void;
    has(): boolean;
}
declare class RowDetailCache<K = RowDetailCacheKey, T = RowDetailCacheEntry> implements RowDetailCacheStorage<K, T> {
    private cacheStorage;
    constructor(cache?: boolean | number);
    add(key: K, value: T): void;
    get(key: K): T | undefined;
    delete(key: K): void;
    has(key: K): boolean;
}

type BooleanCollectionStateKeys<KeyType> = true | KeyType[];
type BooleanCollectionStateObject<KeyType> = {
    positiveItems: BooleanCollectionStateKeys<KeyType>;
    negativeItems: BooleanCollectionStateKeys<KeyType>;
};
declare abstract class BooleanCollectionState<StateObject, KeyType> {
    protected positiveMap?: Map<KeyType, true>;
    protected negativeMap?: Map<KeyType, true>;
    protected allNegative: boolean;
    protected allPositive: boolean;
    private initialState;
    constructor(state: BooleanCollectionStateObject<KeyType> | BooleanCollectionState<StateObject, KeyType>);
    abstract getPositiveFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
    abstract getNegativeFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
    abstract getState(): StateObject;
    protected getInitialState(): BooleanCollectionStateObject<KeyType>;
    destroy(): void;
    private update;
    protected isDefaultNegativeSelection(): boolean;
    protected isDefaultPositiveSelection(): boolean;
    protected areAllNegative(): boolean;
    protected areAllPositive(): boolean;
    protected makeAllNegative(): void;
    protected makeAllPositive(): void;
    protected isItemPositive(key: KeyType): boolean;
    protected isItemNegative(key: KeyType): boolean;
    protected setItemValue(key: KeyType, shouldMakePositive: boolean): void;
    protected makeItemNegative(key: KeyType): void;
    protected makeItemPositive(key: KeyType): void;
    protected toggleItem(key: KeyType): void;
}

type DiscriminatedUnion<A, B> = (A & {
    [K in keyof B]?: undefined;
}) | (B & {
    [K in keyof A]?: undefined;
});
type KeyOfNoSymbol<T> = Exclude<keyof T, Symbol>;
/**
 * Restrict using either exclusively the keys of T or exclusively the keys of U.
 *
 * No unique keys of T can be used simultaneously with any unique keys of U.
 *
 * @example
 *```
 * const myVar: XOR<T, U>
 *```
 *
 * @see https://github.com/maninak/ts-xor/tree/master#description
 */
type XOR<T, U> = T | U extends object ? Prettify<Without<T, U> & U> | Prettify<Without<U, T> & T> : T | U;
/**
 * Useful if applying XOR on more than 2 types.
 * It comes with the penalty of having the types wrapped in an array
 *
 * @example
 * ```
 * AllXOR<[
 *   { a: AModule },
 *   { b: BModule },
 *   { c: CModule },
 *   { d: DModule }
 * ]>
 * ```
 * @see https://github.com/Microsoft/TypeScript/issues/14094#issuecomment-723571692
 */
type AllXOR<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? AllXOR<[XOR<A, B>, ...Rest]> : never;
/**
 * Get the keys of T without any keys of U.
 */
type Without<T, U> = {
    [P in Exclude<keyof T, keyof U>]?: never;
};
/**
 * Resolve mapped types and show the derived keys and their types when hovering in
 * IDEs, instead of just showing the names those mapped types are defined with.
 */
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

type ValueGetterParams<T> = {
    data: T;
    field?: keyof T;
};
type GroupKeyType$1<T extends any = any> = T;
type GroupByValueGetter<T> = (params: ValueGetterParams<T>) => any;
type GroupBy<DataType, KeyType = any> = {
    toKey?: (value: any, data: DataType) => GroupKeyType$1<KeyType>;
    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
} & AllXOR<[
    {
        field: KeyOfNoSymbol<DataType>;
    },
    {
        valueGetter: GroupByValueGetter<DataType>;
        field: KeyOfNoSymbol<DataType>;
    },
    {
        valueGetter: GroupByValueGetter<DataType>;
        field?: KeyOfNoSymbol<DataType>;
        groupField: string;
    }
]>;

type SortDir = 1 | -1;
type MultisortInfo<T> = {
    /**
     * The sorting direction
     */
    dir: SortDir;
    /**
     * for now 'string' and 'number' are known types, meaning they have
     * sort functions already implemented
     */
    type?: string | string[];
    fn?: (a: any, b: any) => number;
    /**
     * a property whose value to use for sorting on the array items
     */
    field?: keyof T;
    /**
     * or a function to retrieve the item value to use for sorting
     */
    valueGetter?: (item: T) => any;
};
type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
    field?: keyof T | (keyof T | ((item: T) => any))[];
};
declare const multisort: {
    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options?: {
        get?: (item: any) => T;
    } | ((item: any) => T)): T[];
    knownTypes: {
        [key: string]: (first: any, second: any) => number;
    };
};
type NestedMultiSortOptions<T> = {
    get?: (item: any) => T;
    nodesKey: string;
    isLeafNode?: (item: T) => boolean;
    getNodeChildren?: (item: T) => null | T[];
    toKey: (item: T) => any;
    depthFirst?: boolean;
    inplace?: boolean;
};
declare const multisortNested: <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], options: NestedMultiSortOptions<T>) => T[];

type MenuIconProps = {
    lineWidth?: number;
    lineStyle?: React$1.CSSProperties;
    style?: React$1.CSSProperties;
    className?: string;
    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
    reserveSpaceWhenHidden?: boolean;
    menuVisible?: boolean;
    children?: React$1.ReactNode;
};
declare function MenuIcon(props: MenuIconProps): React$1.JSX.Element;

type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
type InfiniteTableToggleTreeNodeFn = (nodePath: any[]) => void;
type InfiniteTableToggleRowDetailsFn = (id: any) => void;
type InfiniteTableSelectRowFn = (id: any) => void;
type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
    dragging: boolean;
    column: COL_TYPE;
    columnsMap: Map<string, COL_TYPE>;
    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
    columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
    selectionMode: DataSourcePropSelectionMode;
    horizontalLayoutPageIndex: null | number;
    allRowsSelected: boolean;
    someRowsSelected: boolean;
    filtered: boolean;
    api: InfiniteTableApi<DATA_TYPE>;
    dataSourceApi: DataSourceApi<DATA_TYPE>;
    columnApi: InfiniteTableColumnApi<DATA_TYPE>;
    renderBag: {
        all?: Renderable;
        header: string | number | Renderable;
        sortIcon?: Renderable;
        menuIcon?: Renderable;
        menuIconProps?: MenuIconProps;
        filterIcon?: Renderable;
        filterEditor?: Renderable;
        selectionCheckBox?: Renderable;
    };
} & ({
    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
    insideColumnMenu: false;
} | {
    insideColumnMenu: true;
});
type InfiniteTableColumnRenderBag = {
    value: string | number | Renderable;
    groupIcon?: Renderable;
    treeIcon?: Renderable;
    rowDetailsIcon?: Renderable;
    all?: Renderable;
    selectionCheckBox?: Renderable;
};
type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
    rowIndexInHorizontalLayoutPage: null | number;
    horizontalLayoutPageIndex: null | number;
    value: string | number | Renderable;
    align: InfiniteTableColumnAlignValues;
    verticalAlign: InfiniteTableColumnVerticalAlignValues;
    renderBag: InfiniteTableColumnRenderBag;
    rowIndex: number;
    rowActive: boolean;
    api: InfiniteTableApi<DATA_TYPE>;
    dataSourceApi: DataSourceApi<DATA_TYPE>;
    editError?: Error;
    column: COL_TYPE;
    columnsMap: Map<string, COL_TYPE>;
    fieldsToColumn: Map<keyof DATA_TYPE, COL_TYPE>;
    groupByColumn?: InfiniteTableComputedColumn<DATA_TYPE>;
    toggleCurrentGroupRow: () => void;
    toggleCurrentTreeNode: () => void;
    expandTreeNode: InfiniteTableToggleTreeNodeFn;
    collapseTreeNode: InfiniteTableToggleTreeNodeFn;
    toggleGroupRow: InfiniteTableToggleGroupRowFn;
    toggleTreeNode: InfiniteTableToggleTreeNodeFn;
    toggleCurrentTreeNodeSelection: () => void;
    toggleCurrentGroupRowSelection: () => void;
    toggleCurrentRowSelection: () => void;
    toggleCurrentRowDetails: () => void;
    toggleRowDetails: InfiniteTableToggleRowDetailsFn;
    expandRowDetails: InfiniteTableToggleRowDetailsFn;
    collapseRowDetails: InfiniteTableToggleRowDetailsFn;
    rowHasSelectedCells: boolean;
    cellSelected: boolean;
    selectCurrentRow: () => void;
    selectRow: InfiniteTableSelectRowFn;
    deselectRow: InfiniteTableSelectRowFn;
    deselectCurrentRow: () => void;
    selectCell: () => void;
    deselectCell: () => void;
    toggleRowSelection: InfiniteTableSelectRowFn;
    toggleGroupRowSelection: InfiniteTableToggleGroupRowFn;
    toggleTreeNodeSelection: InfiniteTableToggleTreeNodeFn;
    selectTreeNode: InfiniteTableToggleTreeNodeFn;
    deselectTreeNode: InfiniteTableToggleTreeNodeFn;
    selectionMode: DataSourcePropSelectionMode | undefined;
    rootGroupBy: DataSourceState<DATA_TYPE>['groupBy'];
    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
};
type InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE>;
type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
    data: DATA_TYPE | Partial<DATA_TYPE> | null;
    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
    rowIndex: number;
    column: COL_TYPE;
};
type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
    isGroupRow: true;
}) => Renderable | null;
type InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
    isTreeNode: true;
    isParentNode: true;
}) => Renderable | null;
type InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
    isTreeNode: true;
    isParentNode: false;
}) => Renderable | null;
type InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, EXTRA_NODE_PARAMS = Partial<InfiniteTableRowInfoDataDiscriminator_ParentNode<DATA_TYPE> | InfiniteTableRowInfoDataDiscriminator_LeafNode<DATA_TYPE>>, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & EXTRA_NODE_PARAMS) => Renderable | null;
type InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE> & {
    isGroupRow: false;
}) => Renderable | null;
type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnCellContextType<DATA_TYPE, COL_TYPE>) => Renderable | null;
type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
type InfiniteTableColumnOrHeaderRenderFunction<T> = (params: (InfiniteTableColumnCellContextType<T> & {
    rowInfo: InfiniteTableRowInfo<T>;
}) | (InfiniteTableColumnHeaderParam<T> & {
    rowInfo: null;
})) => ReturnType<InfiniteTableColumnRenderFunction<T>>;
type InfiniteTableColumnContentFocusable<T> = boolean | InfiniteTableColumnContentFocusableFn<T>;
type InfiniteTableColumnEditable<T> = boolean | InfiniteTableColumnEditableFn<T>;
type InfiniteTableColumnContentFocusableFn<T> = (params: InfiniteTableColumnContentFocusableParams<T>) => boolean;
type InfiniteTableColumnEditableFn<T> = (params: InfiniteTableColumnEditableParams<T>) => boolean | Promise<boolean>;
type InfiniteTableColumnContentFocusableParams<T> = InfiniteTableRowInfoDataDiscriminatorWithColumnAndApis<T>;
type InfiniteTableColumnEditableParams<T> = InfiniteTableColumnContentFocusableParams<T>;
type InfiniteTableColumnGetValueToPersistParams<T> = InfiniteTableColumnEditableParams<T> & {
    initialValue: any;
};
type InfiniteTableColumnAlignValues = 'start' | 'center' | 'end';
type InfiniteTableColumnVerticalAlignValues = 'start' | 'center' | 'end';
type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
type InfiniteTableColumnStylingFnParams<T> = {
    value: Renderable;
    column: InfiniteTableComputedColumn<T>;
    rowIndexInHorizontalLayoutPage: null | number;
    horizontalLayoutPageIndex: null | number;
    inEdit: boolean;
    rowHasSelectedCells: boolean;
    editError: InfiniteTableColumnRenderParamBase<T>['editError'];
} & InfiniteTableRowInfoDataDiscriminator<T>;
type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStylingFnParams<T>) => undefined | React$1.CSSProperties;
type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React$1.CSSProperties;
type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStylingFnParams<T>) => undefined | string;
type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
type InfiniteTableColumnAlign<T> = InfiniteTableColumnAlignValues | InfiniteTableColumnAlignFn<T>;
type InfiniteTableColumnVerticalAlign<T> = InfiniteTableColumnVerticalAlignValues | InfiniteTableColumnVerticalAlignFn<T>;
type InfiniteTableColumnAlignFn<T> = (params: InfiniteTableColumnAlignFnParams<T>) => InfiniteTableColumnAlignValues;
type InfiniteTableColumnAlignFnParams<T> = XOR<{
    isHeader: true;
    column: InfiniteTableComputedColumn<T>;
}, InfiniteTableColumnStylingFnParams<T> & {
    isHeader: false;
}>;
type InfiniteTableColumnVerticalAlignFn<T> = (params: InfiniteTableColumnAlignFnParams<T>) => InfiniteTableColumnVerticalAlignValues;
type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
type InfiniteTableColumnValueGetterParams<T> = ValueGetterParams<T>;
type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
type InfiniteTableColumnSortableFn<T> = (context: {
    api: InfiniteTableApi<T>;
    columnApi: InfiniteTableColumnApi<T>;
    column: InfiniteTableComputedColumn<T>;
    columns: Map<string, InfiniteTableComputedColumn<T>>;
}) => boolean;
type InfiniteTableColumnSortable<T> = boolean | InfiniteTableColumnSortableFn<T>;
/**
 * Defines a column in the table.
 *
 * @typeParam DATA_TYPE The type of the data in the table.
 *
 * Can be bound to a field which is a `keyof DATA_TYPE`.
 */
type InfiniteTableColumn<DATA_TYPE> = {
    field?: KeyOfNoSymbol<DATA_TYPE>;
    valueGetter?: InfiniteTableColumnValueGetter<DATA_TYPE>;
    defaultSortable?: InfiniteTableColumnSortable<DATA_TYPE>;
    /**
     * Whether the column is draggable by default.
     *
     * This prop overrides the top-level columnDefaultDraggable prop, but is
     * overridden by the top-level draggableColumns prop.
     */
    defaultDraggable?: boolean;
    resizable?: boolean;
    shouldAcceptEdit?: (params: InfiniteTablePropOnEditAcceptedParams<DATA_TYPE>) => boolean | Error | Promise<boolean | Error>;
    contentFocusable?: InfiniteTableColumnContentFocusable<DATA_TYPE>;
    defaultEditable?: InfiniteTableColumnEditable<DATA_TYPE>;
    getValueToEdit?: (params: InfiniteTableColumnEditableParams<DATA_TYPE>) => any | Promise<any>;
    getValueToPersist?: (params: InfiniteTableColumnGetValueToPersistParams<DATA_TYPE>) => any | Promise<any>;
    comparer?: InfiniteTableColumnComparer<DATA_TYPE>;
    defaultHiddenWhenGroupedBy?: '*' | true | keyof DATA_TYPE | {
        [k in keyof Partial<DATA_TYPE>]: true;
    };
    align?: InfiniteTableColumnAlign<DATA_TYPE>;
    headerAlign?: InfiniteTableColumnAlign<DATA_TYPE>;
    verticalAlign?: InfiniteTableColumnVerticalAlign<DATA_TYPE>;
    columnGroup?: string;
    header?: InfiniteTableColumnHeader<DATA_TYPE>;
    renderHeader?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
    name?: Renderable;
    cssEllipsis?: boolean;
    headerCssEllipsis?: boolean;
    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
    dataType?: InfiniteTableDataTypeNames;
    sortType?: string | string[];
    filterType?: string;
    style?: InfiniteTableColumnStyle<DATA_TYPE>;
    headerStyle?: InfiniteTableColumnHeaderStyle<DATA_TYPE>;
    headerClassName?: InfiniteTableColumnHeaderClassName<DATA_TYPE>;
    className?: InfiniteTableColumnClassName<DATA_TYPE>;
    rowspan?: InfiniteTableColumnRowspanFn<DATA_TYPE>;
    render?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
    renderValue?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
    renderGroupValue?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
    renderLeafValue?: InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE>;
    valueFormatter?: InfiniteTableColumnValueFormatter<DATA_TYPE, Renderable>;
    defaultWidth?: number;
    defaultFlex?: number;
    defaultFilterable?: boolean;
    minWidth?: number;
    maxWidth?: number;
    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
    renderRowDetailIcon?: boolean | InfiniteTableColumnRenderFunction<DATA_TYPE>;
    renderTreeIcon?: boolean | InfiniteTableColumnRenderFunctionForNode<DATA_TYPE, {
        isTreeNode: true;
        isParentNode: boolean;
        isGroupRow: false;
        nodeExpanded: boolean;
    }>;
    renderTreeIconForParentNode?: InfiniteTableColumnRenderFunctionForParentNode<DATA_TYPE, {
        isTreeNode: true;
        isGroupRow: true;
        isParentNode: true;
    }>;
    renderTreeIconForLeafNode?: InfiniteTableColumnRenderFunctionForLeafNode<DATA_TYPE, {
        isTreeNode: true;
        isGroupRow: false;
        isLeafNode: true;
    }>;
    renderSortIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
    renderFilterIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
    renderSelectionCheckBox?: boolean | InfiniteTableColumnOrHeaderRenderFunction<DATA_TYPE>;
    renderMenuIcon?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
    renderHeaderSelectionCheckBox?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
    components?: {
        ColumnCell?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
        HeaderCell?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
        Editor?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
        FilterEditor?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
        FilterOperatorSwitch?: React$1.ComponentType<HTMLProps<HTMLDivElement>>;
        MenuIcon?: React$1.ComponentType<MenuIconProps>;
    };
};
type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'defaultSortable'> & {
    groupByForColumn: GroupBy<T> | GroupBy<T>[];
    id?: string;
};
type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
    pivotBy: DataSourcePivotBy<DataType>[];
    pivotTotalColumnGroup?: true;
    pivotGroupKeys: KeyType[];
    pivotByAtIndex: PivotBy<DataType, KeyType>;
    pivotGroupKey: KeyType;
    pivotIndex: number;
};
type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
    pivotBy: DataSourcePivotBy<DataType>[];
    pivotColumn: true;
    pivotTotalColumn: boolean;
    pivotAggregator: AggregationReducer<DataType, any>;
    pivotAggregatorIndex: number;
    pivotGroupKeys: KeyType[];
    pivotByAtIndex?: PivotBy<DataType, KeyType>;
    pivotIndex: number;
    pivotGroupKey: KeyType;
};
type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
type InfiniteTableComputedColumnBase<T> = {
    computedFilterType: string;
    computedSortType: string | string[];
    computedDataType: string;
    computedWidth: number;
    computedFlex: number | null;
    computedMinWidth: number;
    computedMaxWidth: number;
    computedOffset: number;
    computedPinningOffset: number;
    computedAbsoluteOffset: number;
    computedSortInfo: DataSourceSingleSortInfo<T> | null;
    computedSorted: boolean;
    computedSortedAsc: boolean;
    computedSortedDesc: boolean;
    computedSortIndex: number;
    computedVisible: boolean;
    computedVisibleIndex: number;
    computedVisibleIndexInCategory: number;
    computedMultiSort: boolean;
    computedFiltered: boolean;
    computedFilterable: boolean;
    computedFilterValue: DataSourceFilterValueItem<T> | null;
    computedPinned: InfiniteTableColumnPinnedValues;
    computedDraggable: boolean;
    computedResizable: boolean;
    computedFirstInCategory: boolean;
    computedLastInCategory: boolean;
    computedFirst: boolean;
    computedLast: boolean;
    computedEditable: NonUndefined<InfiniteTableColumn<T>['defaultEditable']>;
    computedSortable: NonUndefined<InfiniteTableColumn<T>['defaultSortable']>;
    colType: InfiniteTableColumnType<T>;
    id: string;
};
type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;

type ForceOptions = {
    force?: boolean;
};
type TreeExpandStateApi<T> = {
    isNodeExpanded(nodePath: any[]): boolean;
    isNodeReadOnly(nodePath: any[]): boolean;
    expandNode(nodePath: any[], options?: ForceOptions): void;
    collapseNode(nodePath: any[], options?: ForceOptions): void;
    toggleNode(nodePath: any[], options?: ForceOptions): void;
    getNodeDataByPath(nodePath: any[]): T | null;
    getRowInfoByPath(nodePath: any[]): InfiniteTableRowInfo<T> | null;
};
type TreeSelectionApi<_T = any> = {
    get allRowsSelected(): boolean;
    isNodeSelected(nodePath: NodePath$1): boolean | null;
    selectNode(nodePath: NodePath$1, options?: ForceOptions): void;
    setNodeSelection(nodePath: NodePath$1, selected: boolean, options?: ForceOptions): void;
    deselectNode(nodePath: NodePath$1, options?: ForceOptions): void;
    toggleNodeSelection(nodePath: NodePath$1, options?: ForceOptions): void;
    selectAll(): void;
    expandAll(): void;
    collapseAll(): void;
    deselectAll(): void;
};
type TreeApi<T> = TreeExpandStateApi<T> & TreeSelectionApi<T>;

type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
type BooleanDeepCollectionStateObject<KeyType> = {
    positiveItems: BooleanDeepCollectionStateKeys<KeyType>;
    negativeItems: BooleanDeepCollectionStateKeys<KeyType>;
};
declare abstract class BooleanDeepCollectionState<StateObject, KeyType extends any = any> {
    protected positiveMap?: DeepMap<KeyType, true>;
    protected negativeMap?: DeepMap<KeyType, true>;
    protected allNegative: boolean;
    protected allPositive: boolean;
    private initialState;
    constructor(state: BooleanDeepCollectionStateObject<KeyType> | BooleanDeepCollectionState<StateObject, KeyType>);
    abstract getPositiveFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
    abstract getNegativeFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
    abstract getState(): StateObject;
    protected getInitialState(): BooleanDeepCollectionStateObject<KeyType>;
    destroy(): void;
    private update;
    protected areAllNegative(): boolean;
    protected areAllPositive(): boolean;
    protected makeAllNegative(): void;
    protected makeAllPositive(): void;
    protected isItemPositive(keys: KeyType[]): boolean | undefined;
    protected isItemNegative(keys: KeyType[]): boolean;
    protected setItemValue(keys: KeyType[], shouldMakePositive: boolean): void;
    protected makeItemNegative(keys: KeyType[]): void;
    protected makeItemPositive(keys: KeyType[]): void;
    protected toggleItem(keys: KeyType[]): void;
}

declare class GroupRowsState<KeyType extends any = any> extends BooleanDeepCollectionState<DataSourcePropGroupRowsStateObject<KeyType>, KeyType> {
    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
    getPositiveFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
    getNegativeFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
    areAllCollapsed(): boolean;
    areAllExpanded(): boolean;
    collapseAll(): void;
    expandAll(): void;
    isGroupRowExpanded(keys: KeyType[]): boolean | undefined;
    isGroupRowCollapsed(keys: KeyType[]): boolean;
    setGroupRowExpanded(keys: KeyType[], shouldExpand: boolean): void;
    collapseGroupRow(keys: KeyType[]): void;
    expandGroupRow(keys: KeyType[]): void;
    toggleGroupRow(keys: KeyType[]): void;
}

type IndexerOptions<DataType, PrimaryKeyType> = {
    toPrimaryKey: (data: DataType) => PrimaryKeyType;
    cache?: DataSourceCache<DataType, PrimaryKeyType>;
    getNodeChildren?: TreeParams<DataType, PrimaryKeyType>['getNodeChildren'];
    isLeafNode?: TreeParams<DataType, PrimaryKeyType>['isLeafNode'];
    nodesKey: string | undefined;
};
declare class Indexer<DataType, PrimaryKeyType = string> {
    primaryKeyToData: Map<PrimaryKeyType, DataType>;
    nodePathsToData: DeepMap<PrimaryKeyType, DataType>;
    private removeNodePath;
    private remove;
    private add;
    private addNodePath;
    clear: () => void;
    getDataForPrimaryKey: (primaryKey: PrimaryKeyType) => DataType | undefined;
    getDataForNodePath: (nodePath: NodePath$1) => DataType | undefined;
    indexArray: (arr: DataType[], options: IndexerOptions<DataType, PrimaryKeyType>) => DataType[];
}

declare class RowDisabledState<KeyType = any> extends BooleanCollectionState<RowDisabledStateObject<KeyType>, KeyType> {
    constructor(state: RowDisabledStateObject<KeyType> | RowDisabledState<KeyType>);
    getState(): RowDisabledStateObject<KeyType>;
    getPositiveFromState(state: RowDisabledStateObject<KeyType>): true | KeyType[];
    getNegativeFromState(state: RowDisabledStateObject<KeyType>): true | KeyType[];
    areAllDisabled(): boolean;
    areAllEnabled(): boolean;
    disableAll(): void;
    enableAll(): void;
    isRowEnabled: (key: KeyType) => boolean;
    isRowDisabled(key: KeyType): boolean;
    setRowEnabled(key: KeyType, enabled: boolean): void;
    disableRow(key: KeyType): void;
    enableRow(key: KeyType): void;
    toggleRow(key: KeyType): void;
}

type RowSelectionStateItem = (any | any[])[];
type RowSelectionStateObject = {
    selectedRows: RowSelectionStateItem;
    deselectedRows: RowSelectionStateItem;
    defaultSelection: boolean;
} | {
    defaultSelection: true;
    deselectedRows: RowSelectionStateItem;
    selectedRows?: RowSelectionStateItem;
} | {
    defaultSelection: false;
    selectedRows: RowSelectionStateItem;
    deselectedRows?: RowSelectionStateItem;
};
type RowSelectionStateConfig<T> = {
    groupBy: DataSourceState<T>['groupBy'];
    groupDeepMap: DataSourceState<T>['groupDeepMap'];
    toPrimaryKey: DataSourceState<T>['toPrimaryKey'];
    totalCount: number;
    indexer: DataSourceState<T>['indexer'];
    lazyLoad: boolean;
    onlyUsePrimaryKeys: boolean;
};
type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
type RowSelectionStateOverride = {
    getGroupKeysForPrimaryKey: RowSelectionState<any>['getGroupKeysForPrimaryKey'];
    getGroupByLength: RowSelectionState<any>['getGroupByLength'];
    getGroupCount: RowSelectionState<any>['getGroupCount'];
    getGroupKeysDirectlyInsideGroup: RowSelectionState<any>['getGroupKeysDirectlyInsideGroup'];
    getAllPrimaryKeysInsideGroup: RowSelectionState<any>['getAllPrimaryKeysInsideGroup'];
};
declare class RowSelectionState<T = any> {
    selectedRows: RowSelectionStateItem | null;
    deselectedRows: RowSelectionStateItem | null;
    defaultSelection: boolean;
    selectedMap: DeepMap<any, true>;
    deselectedMap: DeepMap<any, true>;
    onlyUsePrimaryKeys: boolean;
    selectionCache: DeepMap<any, boolean | null>;
    selectionCountCache: DeepMap<any, {
        selectedCount: number;
        deselectedCount: number;
    }>;
    getConfig: GetRowSelectionStateConfig<T>;
    getGroupKeysForPrimaryKey(pk: any): any[];
    getGroupDeepMap(): DeepMap<any, DeepMapGroupValueType<T, any>> | undefined;
    getGroupCount(groupKeys: any[]): number;
    getGroupKeysDirectlyInsideGroup(groupKeys: any[]): any[][];
    getAllPrimaryKeysInsideGroup(groupKeys: any[]): any[];
    getGroupByLength(): number;
    static from<T>(rowSeleStateObject: RowSelectionStateObject, getConfig: GetRowSelectionStateConfig<T>, overrides?: RowSelectionStateOverride): RowSelectionState<T>;
    constructor(state: RowSelectionStateObject | RowSelectionState, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverride);
    mapSet: (name: "selected" | "deselected", key: any | any[]) => void;
    _selectedMapSet: (key: any | any[]) => void;
    _deselectedMapSet: (key: any | any[]) => void;
    update(stateObject: RowSelectionStateObject): void;
    private xcache;
    getState(): RowSelectionStateObject;
    deselectAll(): void;
    selectAll(): void;
    isRowDefaultSelected(): boolean;
    isRowDefaultDeselected(): boolean;
    /**
     *
     * @param key the id of the row - if a row in a grouped datasource, this is the final row id, without the group keys
     * @param groupKeys the keys of row parents, in order
     * @returns Whether the row is selected or not.
     */
    isRowSelected(key: any, groupKeys?: any[]): boolean;
    isRowDeselected(key: any, groupKeys?: any[]): boolean;
    setRowSelected(key: string | number, selected: boolean, groupKeys?: any[]): void;
    /**
     * Returns if the selection state ('full','partial','none') for the current group
     *
     * The selection state will be full (true) if either of those are true:
     *  * the group keys are specified as selected
     *  * all the children are specified as selected
     *
     * The selection state will be partial (null) if either of those are true:
     *  * the group keys are partially selected
     *  * some of the children are specified as selected
     *
     *
     * @param groupKeys the keys of the group row
     * @param children leaf children that belong to the group
     * @returns boolean
     */
    getGroupRowSelectionState(initialGroupKeys: any[]): boolean | null;
    private getGroupRowBooleanSelectionStateFromParent;
    isGroupRowPartlySelected(groupKeys: any[]): boolean;
    isGroupRowSelected(groupKeys: any[]): boolean;
    isGroupRowDeselected(groupKeys: any[]): boolean;
    selectGroupRow(groupKeys: any[]): void;
    deselectGroupRow(groupKeys: any[]): void;
    setRowAsSelected(key: string | number, groupKeys?: any[]): void;
    setRowAsDeselected(key: string | number, groupKeys?: any[]): void;
    deselectRow(key: any, groupKeys?: any[]): void;
    selectRow(key: any, groupKeys?: any[]): void;
    toggleGroupRowSelection(groupKeys: any[]): void;
    toggleRowSelection(key: string | number, groupKeys?: any[] | undefined): void;
    getSelectedCount(): number;
    getDeselectedCount(): number;
    getSelectionCountFor(groupKeys?: any[], parentSelected?: boolean): {
        selectedCount: number;
        deselectedCount: number;
    };
}

declare const DS_ERROR_CODES: Record<"DS001", DebugWarningPayload>;
declare const INFINITE_ERROR_CODES: Record<"CSS001_CSS", DebugWarningPayload>;
declare const ERROR_CODES: {
    CSS001_CSS: DebugWarningPayload;
    DS001: DebugWarningPayload;
};

type DevToolsMessageAddress = 'infinite-table-devtools-contentscript' | 'infinite-table-devtools-contentscript-panel' | 'infinite-table-devtools-background' | 'infinite-table-page';
type DevToolsGenericMessage = {
    source: DevToolsMessageAddress;
    target: DevToolsMessageAddress;
    payload: any;
    type: string;
};
type ErrorCodeKey = keyof typeof ERROR_CODES;
type DataSourceDebugWarningKey = keyof typeof DS_ERROR_CODES;
type InfiniteTableDebugWarningKey = keyof typeof INFINITE_ERROR_CODES;
type DebugWarningPayload = {
    message: string;
    code: ErrorCodeKey;
    type: 'error' | 'warning';
    status?: 'new' | 'discarded';
    debugId?: string;
};
type DevToolsHookFnOptions = {
    getState: () => InfiniteTableState<any>;
    getDataSourceState: () => DataSourceState<any>;
    getComputed: () => InfiniteTableComputedValues<any>;
    actions: InfiniteTableActions<any>;
    dataSourceActions: DataSourceComponentActions<any>;
    api: InfiniteTableApi<any>;
    dataSourceApi: DataSourceApi<any>;
};
type DevToolsOverrides = Partial<DevToolsInfiniteOverrides & DevToolsDataSourceOverrides>;
type DevToolsInfiniteOverrides = Partial<{
    groupRenderStrategy: InfiniteTableState<any>['groupRenderStrategy'];
    columnVisibility: InfiniteTableState<any>['columnVisibility'];
}>;
type DevToolsDataSourceOverrides = Partial<{
    groupBy: DataSourceState<any>['groupBy'];
    sortInfo: DataSourceState<any>['sortInfo'];
    multiSort: DataSourceState<any>['multiSort'];
}>;
type DevToolsHostPageMessagePayload = {
    debugId: string;
    columnOrder: string[];
    visibleColumnIds: string[];
    columnVisibility: InfiniteTableState<any>['columnVisibility'];
    columns: Record<string, {
        field: InfiniteTableComputedColumn<any>['field'];
        dataType: InfiniteTableComputedColumn<any>['computedDataType'];
        sortType: InfiniteTableComputedColumn<any>['computedSortType'];
        filtered: InfiniteTableComputedColumn<any>['computedFiltered'];
        sorted: InfiniteTableComputedColumn<any>['computedSorted'];
        width: InfiniteTableComputedColumn<any>['computedWidth'];
    }>;
    groupRenderStrategy: InfiniteTableState<any>['groupRenderStrategy'];
    groupBy: string[];
    sortInfo: {
        field: string;
        dir: 1 | -1;
        type?: string;
    }[];
    multiSort: DataSourceState<any>['multiSort'];
    selectionMode: DataSourceState<any>['selectionMode'];
    devToolsDetected: InfiniteTableState<any>['devToolsDetected'];
    debugTimings: Record<DebugTimingKey, number>;
    debugWarnings: Record<ErrorCodeKey, DebugWarningPayload>;
};
type DevToolsHostPageMessageType = 'update' | 'unmount' | 'log';
type DevToolsHostPageLogMessage = {
    type: Extract<DevToolsHostPageMessageType, 'log'>;
    payload: DevToolsHostPageLogMessagePayload;
};
type DevToolsHostPageLogMessagePayload = {
    channel: string;
    color: string;
    args: any[];
    timestamp: number;
    debugId?: string;
};
type DevToolsHostPageMessage = {
    source: Extract<DevToolsMessageAddress, 'infinite-table-page'>;
    target: Extract<DevToolsMessageAddress, 'infinite-table-devtools-background'>;
    url: string;
} & ({
    type: Extract<DevToolsHostPageMessageType, 'update'>;
    payload: DevToolsHostPageMessagePayload;
} | {
    type: Extract<DevToolsHostPageMessageType, 'unmount'>;
    payload: {
        debugId: string;
    };
} | DevToolsHostPageLogMessage);
type DevToolsHookFn = (debugId: string, options: null | DevToolsHookFnOptions) => void;

interface DataSourceDataParams<T> {
    originalDataArray: T[];
    masterRowInfo?: InfiniteTableRowInfo<any>;
    sortInfo?: DataSourceSortInfo<T>;
    groupBy?: DataSourcePropGroupBy<T>;
    pivotBy?: DataSourcePropPivotBy<T>;
    filterValue?: DataSourcePropFilterValue<T>;
    refetchKey?: DataSourceProps<T>['refetchKey'];
    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
    lazyLoadBatchSize?: number;
    lazyLoadStartIndex?: number;
    groupKeys?: any[];
    append?: boolean;
    aggregationReducers?: DataSourcePropAggregationReducers<T>;
    livePaginationCursor?: DataSourceLivePaginationCursorValue;
    __cursorId?: DataSourceSetupState<T>['cursorId'];
    changes?: DataSourceDataParamsChanges<T>;
}
type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
type DataSourceSingleSortInfo<T> = MultisortInfoAllowMultipleFields<T> & {
    id?: string;
};
type DataSourceGroupBy<T> = GroupBy<T, any>;
type DataSourcePivotBy<T> = PivotBy<T, any>;
type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
type DataSourceRemoteData<T> = {
    data: T[] | LazyGroupDataItem<T>[];
    mappings?: DataSourceMappings;
    cache?: boolean;
    error?: string;
    totalCount?: number;
    totalCountUnfiltered?: number;
    livePaginationCursor?: DataSourceLivePaginationCursorValue;
};
type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
type DataSourceGroupRowsList<KeyType = any> = true | KeyType[][];
type DataSourcePropGroupRowsStateObject<KeyType = any> = {
    expandedRows: DataSourceGroupRowsList<KeyType>;
    collapsedRows: DataSourceGroupRowsList<KeyType>;
};
type RowDetailStateObject<KeyType = any> = {
    expandedRows: true | KeyType[];
    collapsedRows: true | KeyType[];
};
type RowDisabledStateObject<KeyType = any> = {
    enabledRows: true;
    disabledRows: KeyType[];
} | {
    disabledRows: true;
    enabledRows: KeyType[];
};
type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
interface DataSourceMappedState<T> {
    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
    livePagination: DataSourceProps<T>['livePagination'];
    refetchKey: NonUndefined<DataSourceProps<T>['refetchKey']>;
    isRowSelected: DataSourceProps<T>['isRowSelected'];
    isNodeSelected: TreeDataSourceProps<T>['isNodeSelected'];
    isNodeExpanded: TreeDataSourceProps<T>['isNodeExpanded'];
    isNodeCollapsed: TreeDataSourceProps<T>['isNodeCollapsed'];
    isNodeReadOnly: NonUndefined<TreeDataSourceProps<T>['isNodeReadOnly']>;
    isNodeSelectable: NonUndefined<TreeDataSourceProps<T>['isNodeSelectable']>;
    onNodeCollapse: TreeDataSourceProps<T>['onNodeCollapse'];
    onNodeExpand: TreeDataSourceProps<T>['onNodeExpand'];
    isRowDisabled: DataSourceProps<T>['isRowDisabled'];
    nodesKey: NonUndefined<TreeDataSourceProps<T>['nodesKey']>;
    treeSelection: TreeDataSourceProps<T>['treeSelection'];
    batchOperationDelay: DataSourceProps<T>['batchOperationDelay'];
    onDataArrayChange: DataSourceProps<T>['onDataArrayChange'];
    onDataMutations: DataSourceProps<T>['onDataMutations'];
    onTreeDataMutations: TreeDataSourceProps<T>['onTreeDataMutations'];
    onReady: DataSourceProps<T>['onReady'];
    rowInfoReducers: DataSourceProps<T>['rowInfoReducers'];
    lazyLoad: DataSourceProps<T>['lazyLoad'];
    useGroupKeysForMultiRowSelection: NonUndefined<DataSourceProps<T>['useGroupKeysForMultiRowSelection']>;
    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
    data: DataSourceProps<T>['data'];
    sortFunction: DataSourceProps<T>['sortFunction'];
    filterFunction: DataSourceProps<T>['filterFunction'];
    treeFilterFunction: DataSourceProps<T>['treeFilterFunction'];
    filterValue: DataSourceProps<T>['filterValue'];
    filterTypes: NonUndefined<DataSourceProps<T>['filterTypes']>;
    primaryKey: DataSourceProps<T>['primaryKey'];
    filterDelay: NonUndefined<DataSourceProps<T>['filterDelay']>;
    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
    pivotBy: DataSourceProps<T>['pivotBy'];
    loading: NonUndefined<DataSourceProps<T>['loading']>;
    sortTypes: NonUndefined<DataSourceProps<T>['sortTypes']>;
    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
    sortInfo: DataSourceSingleSortInfo<T>[] | null;
    rowDisabledState: RowDisabledState<T> | null;
}
type DataSourceRawReducer<T, RESULT_TYPE> = {
    initialValue?: RESULT_TYPE | (() => RESULT_TYPE);
    reducer: (accumulator: any, value: T) => RESULT_TYPE;
    done?: (accumulatedValue: RESULT_TYPE, array: T[]) => RESULT_TYPE;
};
type DataSourceAggregationReducer<T, AggregationResultType> = {
    name?: string;
    field?: keyof T;
    initialValue?: AggregationResultType | (() => any);
    getter?: (data: T) => any;
    reducer: string | ((accumulator: any, value: any, data: T, index: number, groupKeys: any[] | undefined) => AggregationResultType | any);
    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
    pivotColumn?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<T>>> | (({ column, }: {
        column: InfiniteTablePivotFinalColumnVariant<T>;
    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotColumn<T>>>);
};
type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
    inheritFromColumn?: string | boolean;
};
type DataSourceMappings = Record<'totals' | 'values', string>;
type LazyGroupDataItem<DataType> = {
    data: Partial<DataType>;
    keys: any[];
    aggregations?: Record<string, any>;
    dataset?: DataSourceRemoteData<DataType>;
    totalChildrenCount?: number;
    pivot?: {
        values: Record<string, any>;
        totals?: Record<string, any>;
    };
};
type LazyRowInfoGroup<DataType> = {
    /**
     * Those are direct children of the current lazy group row
     */
    children: LazyGroupDataItem<DataType>[];
    childrenLoading: boolean;
    childrenAvailable: boolean;
    cache: boolean;
    totalCount: number;
    totalCountUnfiltered: number;
    error?: string;
};
type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
type DebugTimingKey = 'group-and-pivot' | 'filter' | 'sort' | 'pivot' | 'tree';
interface DataSourceSetupState<T> {
    logger: DebugLogger;
    forceRerenderTimestamp: number;
    devToolsDetected: boolean;
    debugTimings: Map<DebugTimingKey, number>;
    debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
    indexer: Indexer<T, any>;
    getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
    __apiRef: React$1.MutableRefObject<DataSourceApi<T> | null>;
    lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
    lastExpandStateInfoRef: React$1.MutableRefObject<{
        state: 'collapsed' | 'expanded';
        nodePath: NodePath$1 | null;
    }>;
    waitForNodePathPromises: DeepMap<any, {
        timestamp: number;
        promise: Promise<boolean>;
        resolve: (value: boolean) => void;
    }>;
    repeatWrappedGroupRows: InfiniteTablePropRepeatWrappedGroupRows<T>;
    /**
     * This is just used for horizontal layout and when repeatWrappedGroupRows is TRUE!!!
     */
    rowsPerPage: number | null;
    totalLeafNodesCount: number;
    destroyedRef: React$1.MutableRefObject<boolean>;
    idToIndexMap: Map<any, number>;
    idToPathMap: Map<any, NodePath$1>;
    pathToIndexMap: DeepMap<any, number>;
    detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
    treeSelectionState?: TreeSelectionState;
    stateReadyAsDetails: boolean;
    cache?: DataSourceCache<T>;
    unfilteredCount: number;
    filteredCount: number;
    rowInfoReducerResults?: Record<string, any>;
    originalDataArrayChanged: boolean;
    originalDataArrayChangedInfo: {
        timestamp: number;
        mutations?: Map<string, DataSourceMutation<T>[]>;
        treeMutations?: DeepMap<any, DataSourceMutation<T>[]>;
    };
    lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
    pivotMappings?: DataSourceMappings;
    propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
    showSeparatePivotColumnForSingleAggregation: boolean;
    dataParams?: DataSourceDataParams<T>;
    originalLazyGroupData: LazyGroupDataDeepMap<T>;
    originalLazyGroupDataChangeDetect: number | string;
    scrollStopDelayUpdatedByTable: number;
    onCleanup: SubscriptionCallback<DataSourceState<T>>;
    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
    originalDataArray: T[];
    lastFilterDataArray?: T[];
    lastSortDataArray?: T[];
    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
    lastTreeDataArray?: InfiniteTableRowInfo<T>[];
    dataArray: InfiniteTableRowInfo<T>[];
    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
    treeDeepMap?: DeepMap<TreeKeyType, DeepMapTreeValueType<T, any>>;
    treePaths?: DeepMap<TreeKeyType, true>;
    groupRowsIndexesInDataArray?: number[];
    reducerResults?: Record<string, AggregationReducerResult>;
    allRowsSelected: boolean;
    someRowsSelected: boolean;
    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
    updatedAt: number;
    reducedAt: number;
    groupedAt: number;
    treeAt: number;
    sortedAt: number;
    filteredAt: number;
    generateGroupRows: boolean;
    postFilterDataArray?: T[];
    postSortDataArray?: T[];
    postGroupDataArray?: InfiniteTableRowInfo<T>[];
    pivotColumns?: Record<string, InfiniteTableColumn<T>>;
    pivotColumnGroups?: Record<string, InfiniteTableColumnGroup>;
}
type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
type TreeSelectionValue = TreeSelectionStateObject | TreeSelectionState;
type DataSourcePropTreeSelection_MultiNode = TreeSelectionValue;
type DataSourcePropRowSelection_SingleRow = null | string | number;
type DataSourcePropTreeSelection_SingleNode = null | string | number;
type DataSourcePropTreeSelection = DataSourcePropTreeSelection_MultiNode | DataSourcePropTreeSelection_SingleNode;
type DataSourcePropCellSelection_MultiCell = CellSelectionStateObject | CellSelectionState;
type DataSourcePropCellSelection_SingleCell = null | CellSelectionPosition;
type DataSourcePropCellSelection = DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
type DataSourcePropOnTreeSelectionChange_MultiNode<T = any> = (treeSelection: TreeSelectionStateObject, params: {
    selectionMode: 'multi-row';
    lastUpdatedNodePath: NodePath$1 | null;
    dataSourceApi: DataSourceApi<T>;
}) => void;
type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
type DataSourcePropOnTreeSelectionChange_SingleNode = (treeSelection: DataSourcePropTreeSelection_SingleNode, params: {
    selectionMode: 'single-row';
}) => void;
type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
type DataSourcePropOnTreeSelectionChange = DataSourcePropOnTreeSelectionChange_SingleNode | DataSourcePropOnTreeSelectionChange_MultiNode;
type DataSourcePropOnCellSelectionChange_MultiCell = (cellSelection: DataSourcePropCellSelection_MultiCell, selectionMode: 'multi-cell') => void;
type DataSourcePropOnCellSelectionChange_SingleCell = (cellSelection: DataSourcePropCellSelection_SingleCell, selectionMode: 'single-cell') => void;
type DataSourcePropOnCellSelectionChange = DataSourcePropOnCellSelectionChange_MultiCell | DataSourcePropOnCellSelectionChange_SingleCell;
type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
type DataSourcePropIsNodeReadOnly<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>) => boolean;
type DataSourcePropIsNodeSelected<T> = (rowInfo: InfiniteTable_Tree_RowInfoNode<T>, treeSelectionState: TreeSelectionState, selectionMode: 'multi-row') => boolean | null;
type DataSourcePropIsNodeSelectable<T> = (rowInfo: InfiniteTable_Tree_RowInfoNode<T>) => boolean;
type DataSourcePropIsNodeExpanded<T> = (rowInfo: InfiniteTable_Tree_RowInfoParentNode<T>, treeExpandState: TreeExpandState) => boolean;
type DataSourcePropSortFn<T> = (sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: (item: any) => T) => T[];
type DataSourceCRUDParam = {
    flush?: boolean;
    metadata?: any;
};
type WaitForNodeOptions = {
    waitForNode?: boolean | number;
};
type DataSourceUpdateParam = DataSourceCRUDParam & WaitForNodeOptions;
type DataSourceInsertParam = DataSourceCRUDParam & WaitForNodeOptions & ({
    position: 'before' | 'after';
    primaryKey: any;
    nodePath?: never;
} | {
    position: 'before' | 'after';
    primaryKey?: never;
    nodePath: NodePath$1;
} | {
    position: 'start' | 'end';
    nodePath?: never;
} | {
    position: 'start' | 'end';
    nodePath: NodePath$1;
});
type UpdateChildrenFn<T> = (dataChildren: T[] | undefined | null, data: T) => T[] | undefined | null;
interface DataSourceApi<T> {
    getPendingOperationPromise(): Promise<boolean> | null;
    getOriginalDataArray: () => T[];
    getRowInfoArray: () => InfiniteTableRowInfo<T>[];
    getDataByPrimaryKey(id: any): T | null;
    getDataByNodePath(nodePath: NodePath$1): T | null;
    getDataByIndex(index: number): T | null;
    getRowInfoByIndex(index: number): InfiniteTableRowInfo<T> | null;
    getRowInfoByPrimaryKey(id: any): InfiniteTableRowInfo<T> | null;
    getRowInfoByNodePath(nodePath: NodePath$1): InfiniteTableRowInfo<T> | null;
    getIndexByPrimaryKey(id: any): number;
    getIndexByNodePath(nodePath: NodePath$1): number;
    getPrimaryKeyByIndex(id: any): any;
    getNodePathById(id: any): NodePath$1 | null;
    getNodePathByIndex(index: number): NodePath$1 | null;
    get treeApi(): TreeApi<T>;
    /**
     * @param nodePath The node path to wait for
     * @param options
     * @param options.timeout The timeout to wait for the node path to be available. Defaults to 1000ms.
     *
     * @returns true if the path is already in the DataSource, otherwise a promise resolving to a boolean value.
     * If the timeout is reached and the path is not available, the promise is resolved to false. Otherwise, the promise is resolved to true.
     */
    waitForNodePath(nodePath: NodePath$1, options?: {
        timeout?: number;
    }): Promise<boolean>;
    isNodePathAvailable(nodePath: NodePath$1): boolean;
    updateData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
    updateDataByNodePath(data: Partial<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
    updateChildrenByNodePath(childrenOrFn: T[] | undefined | null | UpdateChildrenFn<T>, nodePath: NodePath$1, options?: DataSourceUpdateParam): Promise<any>;
    updateDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
    updateDataArrayByNodePath(updateInfo: {
        data: Partial<T>;
        nodePath: NodePath$1;
    }[], options?: DataSourceUpdateParam): Promise<any>;
    flush(): Promise<any>;
    removeDataByPrimaryKey(id: any, options?: DataSourceCRUDParam): Promise<any>;
    removeDataByNodePath(nodePath: NodePath$1, options?: DataSourceCRUDParam): Promise<any>;
    removeDataArrayByPrimaryKeys(id: any[], options?: DataSourceCRUDParam): Promise<any>;
    removeData(data: Partial<T>, options?: DataSourceCRUDParam): Promise<any>;
    removeDataArray(data: Partial<T>[], options?: DataSourceCRUDParam): Promise<any>;
    clearAllData(options?: DataSourceCRUDParam): Promise<any>;
    replaceAllData(data: T[], options?: DataSourceCRUDParam): Promise<any>;
    addData(data: T, options?: DataSourceCRUDParam): Promise<any>;
    addDataArray(data: T[], options?: DataSourceCRUDParam): Promise<any>;
    insertData(data: T, options: DataSourceInsertParam): Promise<any>;
    insertDataArray(data: T[], options: DataSourceInsertParam): Promise<any>;
    setSortInfo(sortInfo: null | DataSourceSingleSortInfo<T>[]): void;
    isRowDisabledAt: (rowIndex: number) => boolean;
    isRowDisabled: (primaryKey: any) => boolean;
    setRowEnabledAt: (rowIndex: number, enabled: boolean) => void;
    setRowEnabled: (primaryKey: any, enabled: boolean) => void;
    enableAllRows: () => void;
    disableAllRows: () => void;
    areAllRowsEnabled: () => boolean;
    areAllRowsDisabled: () => boolean;
    setGroupBy: (groupBy: DataSourceState<T>['groupBy']) => void;
}
type DataSourcePropRowInfoReducers<T> = Record<string, DataSourceRowInfoReducer<T>>;
type DataSourceRowInfoReducer<T> = DataSourceRawReducer<InfiniteTableRowInfo<T>, any>;
type DataSourcePropShouldReloadDataObject<T> = {
    [key in keyof Pick<DataSourceDataParams<T>, 'sortInfo' | 'pivotBy' | 'groupBy' | 'filterValue'>]: boolean;
};
type DataSourcePropShouldReloadData<T> = DataSourcePropShouldReloadDataObject<T> | boolean;
type TreeExpandStateValue = TreeExpandState | TreeExpandStateObject<any>;
type DataSourceProps<T> = {
    nodesKey?: never;
    debugId?: string;
    children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
    primaryKey: keyof T | ((data: T) => string);
    /**
     * @deprecated for now
     */
    fields?: (keyof T)[];
    refetchKey?: number | string | object;
    batchOperationDelay?: number;
    rowInfoReducers?: DataSourcePropRowInfoReducers<T>;
    data: DataSourceData<T>;
    selectionMode?: DataSourcePropSelectionMode;
    useGroupKeysForMultiRowSelection?: boolean;
    rowSelection?: DataSourcePropRowSelection;
    defaultRowSelection?: DataSourcePropRowSelection;
    cellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
    defaultCellSelection?: DataSourcePropCellSelection_MultiCell | DataSourcePropCellSelection_SingleCell;
    onCellSelectionChange?: DataSourcePropOnCellSelectionChange;
    rowDisabledState?: RowDisabledState | RowDisabledStateObject<any>;
    defaultRowDisabledState?: RowDisabledState | RowDisabledStateObject<any>;
    onRowDisabledStateChange?: (rowDisabledState: RowDisabledState) => void;
    isRowDisabled?: (rowInfo: InfiniteTableRowInfo<T>) => boolean;
    isRowSelected?: DataSourcePropIsRowSelected<T>;
    lazyLoad?: boolean | {
        batchSize?: number;
    };
    loading?: boolean;
    defaultLoading?: boolean;
    onLoadingChange?: (loading: boolean) => void;
    onReady?: (api: DataSourceApi<T>) => void;
    pivotBy?: DataSourcePropPivotBy<T>;
    defaultPivotBy?: DataSourcePropPivotBy<T>;
    onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
    aggregationReducers?: DataSourcePropAggregationReducers<T>;
    defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
    groupBy?: DataSourcePropGroupBy<T>;
    defaultGroupBy?: DataSourcePropGroupBy<T>;
    onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
    groupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
    defaultGroupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
    collapseGroupRowsOnDataFunctionChange?: boolean;
    sortFunction?: DataSourcePropSortFn<T>;
    sortInfo?: DataSourceSortInfo<T>;
    defaultSortInfo?: DataSourceSortInfo<T>;
    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
    onDataArrayChange?: (dataArray: DataSourceState<T>['originalDataArray'], info: DataSourceState<T>['originalDataArrayChangedInfo']) => void;
    onDataMutations?: ({ dataArray, timestamp, mutations, primaryKeyField, }: {
        primaryKeyField: undefined | keyof T;
        dataArray: DataSourceState<T>['originalDataArray'];
        timestamp: number;
        mutations: NonUndefined<DataSourceState<T>['originalDataArrayChangedInfo']['mutations']>;
    }) => void;
    livePagination?: boolean;
    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
    filterFunction?: DataSourcePropFilterFunction<T>;
    treeFilterFunction?: DataSourcePropTreeFilterFunction<T>;
    /**
     * @deprecated Use shouldReloadData.sortInfo instead
     */
    sortMode?: 'local' | 'remote';
    /**
     * @deprecated Use shouldReloadData.filterValue instead
     */
    filterMode?: 'local' | 'remote';
    /**
     * @deprecated Use shouldReloadData.groupBy instead
     */
    groupMode?: 'local' | 'remote';
    shouldReloadData?: DataSourcePropShouldReloadData<T>;
    filterValue?: DataSourcePropFilterValue<T>;
    defaultFilterValue?: DataSourcePropFilterValue<T>;
    onFilterValueChange?: (filterValue: DataSourcePropFilterValue<T>) => void;
    filterDelay?: number;
    filterTypes?: DataSourcePropFilterTypes<T>;
    sortTypes?: DataSourcePropSortTypes;
} & ({
    selectionMode?: 'multi-row';
    rowSelection?: DataSourcePropRowSelection_MultiRow;
    defaultRowSelection?: DataSourcePropRowSelection_MultiRow;
    onRowSelectionChange?: DataSourcePropOnRowSelectionChange_MultiRow;
} | {
    selectionMode?: 'single-row';
    rowSelection?: DataSourcePropRowSelection_SingleRow;
    defaultRowSelection?: DataSourcePropRowSelection_SingleRow;
    onRowSelectionChange?: DataSourcePropOnRowSelectionChange_SingleRow;
} | {
    selectionMode?: 'single-cell';
    cellSelection?: DataSourcePropCellSelection_SingleCell;
    defaultCellSelection?: DataSourcePropCellSelection_SingleCell;
    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_SingleCell;
} | {
    selectionMode?: 'multi-cell';
    cellSelection?: DataSourcePropCellSelection_MultiCell;
    defaultCellSelection?: DataSourcePropCellSelection_MultiCell;
    onCellSelectionChange?: DataSourcePropOnCellSelectionChange_MultiCell;
} | {
    selectionMode?: false;
});
/**
 * @deprecated Use DataSourceProps<T> instead
 */
type DataSourcePropsWithChildren<T> = DataSourceProps<T> & {};
type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
type DataSourceFilterFunctionParam<T> = {
    data: T;
    index: number;
    dataArray: T[];
    primaryKey: any;
};
type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
type DataSourcePropTreeFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T> & {
    filterTreeNode: (data: T) => T | boolean;
}) => T | boolean;
type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
    field: keyof T;
}, {
    id: string;
}> & {
    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
    filter: {
        type: string;
        operator: string;
        value: any;
    };
    disabled?: boolean;
};
type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T> & {
    field?: keyof T;
}) => any;
type DataSourceFilterType<T> = {
    emptyValues: any[];
    label?: string;
    defaultOperator: string;
    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
    components?: {
        FilterEditor?: () => React$1.JSX.Element | null;
        FilterOperatorSwitch?: () => React$1.JSX.Element | null;
    };
    operators: DataSourceFilterOperator<T>[];
};
type DataSourceFilterOperator<T> = {
    name: string;
    label?: string;
    components?: {
        FilterEditor?: () => React$1.JSX.Element | null;
        Icon?: (props: any) => React$1.JSX.Element | null;
    };
    fn: DataSourceFilterOperatorFunction<T>;
    defaultFilterValue?: any;
};
type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
type DataSourceFilterOperatorFunctionParam<T> = {
    currentValue: any;
    filterValue: any;
    emptyValues: any[];
    field?: keyof T;
} & DataSourceFilterFunctionParam<T>;
type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
type DataSourceLivePaginationCursorParams<T> = {
    array: T[];
    lastItem: T | Partial<T> | null;
    length: number;
};
type DataSourceLivePaginationCursorValue = string | number | null;
interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
}
type DataSourceCallback_BaseParam<T> = {
    dataSourceApi: DataSourceApi<T>;
};
type DataSourceDerivedState<T> = {
    debugId: DataSourceProps<T>['debugId'];
    isTree: boolean;
    toPrimaryKey: (data: T) => any;
    operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
    sortMode: 'local' | 'remote';
    filterMode: 'local' | 'remote';
    groupMode: 'local' | 'remote';
    pivotMode: 'local' | 'remote';
    shouldReloadData: NonUndefined<Required<DataSourcePropShouldReloadDataObject<T>>>;
    groupRowsState: GroupRowsState<T>;
    treeExpandState: TreeExpandState<any>;
    treeExpandMode: TreeExpandStateMode;
    multiSort: boolean;
    controlledSort: boolean;
    controlledFilter: boolean;
    livePaginationCursor?: DataSourceLivePaginationCursorValue;
    lazyLoadBatchSize?: number;
    rowSelection: RowSelectionState | null | number | string;
    isRowDisabled: DataSourceProps<T>['isRowDisabled'];
    cellSelection: CellSelectionState | null;
    selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
};
type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
interface DataSourceContextValue<T> {
    api: DataSourceApi<T>;
    getState: () => DataSourceState<T>;
    assignState: (state: Partial<DataSourceState<T>>) => void;
    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue<any> | undefined;
    componentState: DataSourceState<T>;
    componentActions: DataSourceComponentActions<T>;
}
interface DataSourceMasterDetailContextValue<MASTER_TYPE = any> {
    registerDetail: (detail: DataSourceContextValue<any>) => void;
    getMasterState: () => InfiniteTableState<MASTER_TYPE>;
    getMasterDataSourceState: () => DataSourceState<MASTER_TYPE>;
    shouldRestoreState: boolean;
    masterRowInfo: InfiniteTableRowInfo<MASTER_TYPE>;
}
declare enum DataSourceActionType {
    INIT = "INIT"
}
interface DataSourceAction<T> {
    type: DataSourceActionType;
    payload: T;
}

declare class RowDetailState<KeyType = any> extends BooleanCollectionState<RowDetailStateObject<KeyType>, KeyType> {
    constructor(state: RowDetailStateObject<KeyType> | RowDetailState<KeyType>);
    getState(): RowDetailStateObject<KeyType>;
    getPositiveFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
    getNegativeFromState(state: RowDetailStateObject<KeyType>): true | KeyType[];
    areAllCollapsed(): boolean;
    areAllExpanded(): boolean;
    collapseAll(): void;
    expandAll(): void;
    isRowDetailsExpanded: (key: KeyType) => boolean;
    isRowDetailsCollapsed(key: KeyType): boolean;
    setRowDetailsExpanded(key: KeyType, shouldExpand: boolean): void;
    collapseRowDetails(key: KeyType): void;
    expandRowDetails(key: KeyType): void;
    toggleRowDetails(key: KeyType): void;
}

type TableRenderCellFnParam = {
    domRef: RefCallback<HTMLElement>;
    rowIndex: number;
    colIndex: number;
    rowspan: number;
    colspan: number;
    hidden: boolean;
    width: number;
    height: number;
    widthWithColspan: number;
    heightWithRowspan: number;
    rowFixed: FixedPosition;
    colFixed: FixedPosition;
    onMouseEnter: VoidFunction;
    onMouseLeave: VoidFunction;
};
type TableRenderDetailRowFnParam = {
    domRef: RefCallback<HTMLElement>;
    rowIndex: number;
    hidden: boolean;
    height: number;
    rowFixed: FixedPosition;
    onMouseEnter: VoidFunction;
    onMouseLeave: VoidFunction;
};
type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
type TableRenderDetailRowFn = (param: TableRenderDetailRowFnParam) => Renderable;
type RenderRangeOptions = {
    force?: boolean;
    renderCell: TableRenderCellFn;
    renderDetailRow?: TableRenderDetailRowFn;
    onRender: (items: Renderable[]) => void;
};
type HorizontalLayoutColVisibilityOptions = {
    horizontalLayoutPageIndex?: number;
};

interface GridCellInterface<T_ADDITIONAL_CELL_INFO = any> {
    debugId: string;
    update(content: Renderable, additionalInfo?: T_ADDITIONAL_CELL_INFO): void;
    getElement(): HTMLElement | null;
    getNode(): Renderable;
    destroy(): void;
    onMount(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
    getAdditionalInfo(): T_ADDITIONAL_CELL_INFO | undefined;
    isMounted(): boolean;
    ref: React.RefCallback<HTMLElement | undefined>;
}

type CellPos = [number, number];

declare class GridCellManager<T_ADDITIONAL_CELL_INFO> extends Logger {
    private matrix;
    private rowsWithCellsHistory;
    private columnsWithCellsHistory;
    private cellToMatrixPosition;
    private pool;
    debugId: string;
    private offRemoveCell;
    constructor(debugId: string);
    private onRemoveCell;
    set poolSize(cellCount: number);
    get poolSize(): number;
    getDetachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
    private clearCellFromMatrix;
    private addCellToMatrix;
    private setCellPositionInMatrix;
    renderNodeAtCell(node: Renderable, cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, cellPos: CellPos, additionalInfo?: T_ADDITIONAL_CELL_INFO): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
    getCellPosition(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): CellPos | null;
    getCellAt(cellPos: CellPos): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
    /**
     * This gets a cell for a given position.
     * If there's already a cell currently attached at that position, it will be returned.
     *
     * Otherwise, we try to return the most optimal cell to use for that position.
     * If the optimise parameter is set to 'row', we will try to return a detached cell
     * that was last rendered in that row.
     *
     * If the optimise parameter is set to 'column', we will try to return a detached cell
     * that was last rendered in that column.
     *
     * @param cellPos [rowIndex, colIndex]
     * @param optimise 'row' | 'column'
     */
    getCellFor(cellPos: CellPos, optimise: 'row' | 'column'): GridCellInterface<T_ADDITIONAL_CELL_INFO>;
    isCellAttached(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
    isCellAttachedAt(cellPos: CellPos): boolean;
    getMatrix(): Renderable[][];
    getAllCells(): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
    getCellsForRow(rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO>[];
    getOneAttachedCell(): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
    getRowsWithCells(): number[];
    getColumnsWithCells(): number[];
    isRowAttached(rowIndex: number): boolean;
    isColumnAttached(colIndex: number): boolean;
    detachRow(rowIndex: number): void;
    detachCol(colIndex: number): void;
    detachCell(cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>): boolean;
    detachCells(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>): void;
    detachRowsStartingWith(rowIndex: number): void;
    detachColsStartingWith(colIndex: number): void;
    detachCellsStartingAt(cellPos: CellPos): void;
    detachCellAt(cellPos: CellPos): boolean;
    onCellAttachmentChange(callback: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>, attached: boolean) => void): VoidFn;
    getCellsOutsideRenderRange: (range: TableRenderRange) => Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>;
    getCellFromListForRow(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, rowIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
    getCellFromListForColumn(cells: Set<GridCellInterface<T_ADDITIONAL_CELL_INFO>>, colIndex: number): GridCellInterface<T_ADDITIONAL_CELL_INFO> | undefined;
    getCellCountInMatrix(): number;
    destroy(): void;
    reset(): void;
    makeDetachedCellsEmpty(): void;
    withDetachedCells(fn: (cell: GridCellInterface<T_ADDITIONAL_CELL_INFO>) => void): void;
}

/**
 * This is only used for rendering Detail rows in a master-detail DataGrid
 */
interface ListRowInterface {
    debugId: string;
    update(content: Renderable): void;
    getElement(): HTMLElement | null;
    getNode(): Renderable;
    destroy(): void;
    onMount(callback: (row: ListRowInterface) => void): void;
    isMounted(): boolean;
    ref: (htmlElement: HTMLElement) => void;
}

declare class ListRowManager extends Logger {
    private pool;
    private indexToRow;
    private rowToIndex;
    debugId: string;
    private offRemoveRow;
    constructor(debugId: string);
    private onRemoveRow;
    set poolSize(rowCount: number);
    get poolSize(): number;
    getDetachedRow(): ListRowInterface;
    /**
     * This gets a row for a given position.
     * If there's already a row currently attached at that position, it will be returned.
     *
     * Otherwise, we return another row.
     * @param rowIndex
     */
    getRowFor(rowIndex: number): ListRowInterface;
    private setRowIndexInList;
    detachStartingWith(rowIndex: number): void;
    getRowAt(rowPos: number): ListRowInterface | undefined;
    getRowIndex(row: ListRowInterface): number | undefined;
    isRowAttached(row: ListRowInterface): boolean;
    isRowAttachedAt(rowIndex: number): boolean;
    getList(): Renderable[];
    getAttachedCount(): number;
    forEachAttachedRow(fn: (row: ListRowInterface) => void): void;
    getAttachedIndexes(): number[];
    getAllRows(): ListRowInterface[];
    detachRowAt(rowIndex: number): void;
    detachRow(row: ListRowInterface): void;
    renderNodeAtRow(node: Renderable, row: ListRowInterface, rowIndex: number): ListRowInterface;
    makeDetachedRowsEmpty(): void;
    onRowAttachmentChange(callback: (row: ListRowInterface, attached: boolean) => void): VoidFn;
    withDetachedRows(fn: (row: ListRowInterface) => void): void;
    destroy(): void;
    reset(): void;
}

declare class GridRenderer extends Logger {
    protected brain: MatrixBrain;
    debugId: string;
    protected destroyed: boolean;
    private scrolling;
    cellHoverClassNames: string[];
    cellDetachedClassNames: string[];
    protected cellManager: GridCellManager<{
        renderRowIndex: number;
        renderColIndex: number;
    }>;
    protected rowManager: ListRowManager;
    private lastEnteredRow;
    private lastExitedRow;
    private onDestroy;
    private hoverRowUpdatesInProgress;
    private infiniteNode;
    private getInfiniteNode;
    setDetailTransform: (element: HTMLElement, _rowIndex: number, { y, scrollTop, scrollLeft, }: {
        y: number;
        scrollTop?: boolean;
        scrollLeft?: number;
    }) => void;
    setTransform: (element: HTMLElement, _rowIndex: number, colIndex: number, { x, y, scrollLeft, scrollTop, }: {
        x: number;
        y: number;
        scrollLeft?: boolean;
        scrollTop?: boolean;
    }, zIndex: number | "auto" | undefined | null) => void;
    constructor(brain: MatrixBrain, debugId?: string);
    private onCellAttached;
    private onCellDetached;
    private onRowAttached;
    private onRowDetached;
    getFullyVisibleRowsRange: () => {
        start: number;
        end: number;
    } | null;
    getScrollPositionForScrollRowIntoView: (rowIndex: number, config?: {
        scrollAdjustPosition?: ScrollAdjustPosition;
        offset?: number;
        colIndex?: number;
    }) => ScrollPosition | null;
    getScrollPositionForScrollColumnIntoView: (colIndex: number, config?: {
        scrollAdjustPosition?: ScrollAdjustPosition;
        offset?: number;
    } & HorizontalLayoutColVisibilityOptions) => ScrollPosition | null;
    getScrollPositionForScrollCellIntoView: (rowIndex: number, colIndex: number, config?: {
        rowScrollAdjustPosition?: ScrollAdjustPosition;
        colScrollAdjustPosition?: ScrollAdjustPosition;
        scrollAdjustPosition?: ScrollAdjustPosition;
        offsetTop: number;
        offsetLeft: number;
    }) => ScrollPosition | null;
    isRowFullyVisible: (rowIndex: number, offsetMargin?: number) => boolean;
    isRowVisible: (rowIndex: number, offsetMargin?: number) => boolean;
    isRowRendered: (rowIndex: number) => boolean;
    isCellVisible: (rowIndex: number, colIndex: number) => boolean;
    isCellFullyVisible: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
    isColumnFullyVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
    isColumnVisible: (colIndex: number, offsetMargin?: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
    isCellRendered: (rowIndex: number, colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
    isColumnRendered: (colIndex: number, opts?: HorizontalLayoutColVisibilityOptions) => boolean;
    getExtraSpanCellsForRange: (range: TableRenderRange) => [number, number][];
    isCellRenderedAndMappedCorrectly(row: number, col: number): {
        rendered: boolean;
        mapped: boolean;
    };
    renderRange(range: TableRenderRange, { renderCell, renderDetailRow, force, onRender }: RenderRangeOptions): Renderable[];
    getFixedRanges: (currentRenderRange: TableRenderRange) => TableRenderRange[];
    protected isCellFixed: (rowIndex: number, colIndex: number) => {
        row: FixedPosition;
        col: FixedPosition;
    };
    protected isCellCovered: (rowIndex: number, colIndex: number) => false | number[];
    private renderDetailRowAtElement;
    protected getCellRealCoordinates(rowIndex: number, colIndex: number): {
        rowIndex: number;
        colIndex: number;
    };
    protected renderCellAt(rowIndex: number, colIndex: number, cell: GridCellInterface, renderCell: TableRenderCellFn): void;
    protected onMouseEnter: (rowIndex: number) => void;
    private addHoverClass;
    protected onMouseLeave: (rowIndex: number) => void;
    private removeHoverClass;
    protected updateHoverClassNamesForRow: (rowIndex: number) => void;
    protected updateElementPosition: (cell: GridCellInterface<{
        renderRowIndex: number;
        renderColIndex: number;
    }>, options?: {
        hidden: boolean;
        rowspan: number;
        colspan: number;
    }) => void;
    private updateDetailElementPosition;
    private onScrollStart;
    private onScrollStop;
    adjustFixedElementsOnScroll: (scrollPosition?: ScrollPosition) => void;
    destroy: () => void;
    reset(): void;
}

type CellPositionByIndex = {
    rowIndex: number;
    colIndex: number;
};
type MultiSelectRangeOptions = {
    horizontalLayout: false;
} | {
    horizontalLayout: true;
    rowsPerPage: number;
    columnsPerSet: number;
};

declare class ScrollListener {
    private scrollPosition;
    private onScrollFns;
    getScrollPosition: () => ScrollPosition;
    onScroll: (fn: OnScrollFn) => () => void;
    setScrollPosition: (scrollPosition: ScrollPosition) => void;
    private notifyScrollChange;
    destroy: () => void;
}

type CellContextMenuLocation = {
    rowId: any;
    rowIndex: number;
    columnId: string;
    colIndex: number;
};
type CellContextMenuLocationWithEvent = CellContextMenuLocation & {
    event: React.MouseEvent;
    target: HTMLElement;
};
type ContextMenuLocationWithEvent = Partial<CellContextMenuLocation> & {
    event: React.MouseEvent;
    target: HTMLElement;
};
interface InfiniteTableSetupState<T> {
    brain: MatrixBrain;
    headerBrain: MatrixBrain;
    renderer: GridRenderer;
    onRenderUpdater: SubscriptionCallback<Renderable>;
    headerRenderer: GridRenderer;
    headerOnRenderUpdater: SubscriptionCallback<Renderable>;
    debugWarnings: Map<InfiniteTableDebugWarningKey, DebugWarningPayload>;
    devToolsDetected: boolean;
    forceBodyRerenderTimestamp: number;
    lastRowToExpandRef: MutableRefObject<any | null>;
    lastRowToCollapseRef: MutableRefObject<any | null>;
    getDOMNodeForCell: (cellPos: CellPositionByIndex) => HTMLElement | null;
    propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
    columnsWhenInlineGroupRenderStrategy?: Record<string, InfiniteTableColumn<T>>;
    domRef: MutableRefObject<HTMLDivElement | null>;
    editingValueRef: MutableRefObject<any | null>;
    scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
    portalDOMRef: MutableRefObject<HTMLDivElement | null>;
    focusDetectDOMRef: MutableRefObject<HTMLDivElement | null>;
    activeCellIndicatorDOMRef: MutableRefObject<HTMLDivElement | null>;
    onFlashingDurationCSSVarChange: SubscriptionCallback<number>;
    flashingDurationCSSVarValue: number | null;
    onRowHeightCSSVarChange: SubscriptionCallback<number>;
    onRowDetailHeightCSSVarChange: SubscriptionCallback<number>;
    onColumnMenuClick: SubscriptionCallback<{
        target: HTMLElement | EventTarget;
        column: InfiniteTableComputedColumn<T>;
    }>;
    onFilterOperatorMenuClick: SubscriptionCallback<{
        target: HTMLElement | EventTarget;
        column: InfiniteTableComputedColumn<T>;
    }>;
    cellContextMenu: SubscriptionCallback<CellContextMenuLocationWithEvent>;
    contextMenu: SubscriptionCallback<ContextMenuLocationWithEvent>;
    cellContextMenuVisibleFor: CellContextMenuLocation | null;
    contextMenuVisibleFor: (Partial<CellContextMenuLocation> & {
        point: PointCoords;
    }) | null;
    columnMenuVisibleForColumnId: string | null;
    columnMenuTargetRef: MutableRefObject<HTMLElement | null>;
    columnMenuVisibleKey: string | number;
    filterOperatorMenuVisibleForColumnId: string | null;
    onColumnHeaderHeightCSSVarChange: SubscriptionCallback<number>;
    cellClick: SubscriptionCallback<CellPositionByIndex & {
        event: MouseEvent;
    }>;
    cellMouseDown: SubscriptionCallback<CellPositionByIndex & {
        event: MouseEvent;
    }>;
    keyDown: SubscriptionCallback<KeyboardEvent>;
    columnsWhenGrouping?: InfiniteTablePropColumns<T>;
    bodySize: Size;
    focused: boolean;
    ready: boolean;
    columnReorderDragColumnId: false | string;
    columnReorderInPageIndex: number | null;
    columnVisibilityForGrouping: Record<string, false>;
    focusedWithin: boolean;
    scrollPosition: ScrollPosition;
    pinnedStartScrollListener: ScrollListener;
    pinnedEndScrollListener: ScrollListener;
    editingCell: {
        active: true;
        accepted: false;
        columnId: string;
        value: any;
        persisted: false;
        initialValue: any;
        rowIndex: number;
        primaryKey: any;
    } | null | {
        active: false;
        columnId: string;
        rowIndex: number;
        value: any;
        initialValue: any;
        primaryKey?: any;
        waiting: 'accept' | 'persist' | false;
        accepted: boolean | Error;
        persisted: boolean | Error;
        cancelled?: boolean;
    };
}
type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
interface InfiniteTableMappedState<T> {
    id: InfiniteTableProps<T>['id'];
    debugId: InfiniteTableProps<T>['debugId'];
    scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
    multiSortBehavior: NonUndefined<InfiniteTableProps<T>['multiSortBehavior']>;
    viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
    resizableColumns: InfiniteTableProps<T>['resizableColumns'];
    groupColumn: InfiniteTableProps<T>['groupColumn'];
    onKeyDown: InfiniteTableProps<T>['onKeyDown'];
    onCellClick: InfiniteTableProps<T>['onCellClick'];
    onCellDoubleClick: InfiniteTableProps<T>['onCellDoubleClick'];
    onRowMouseEnter: InfiniteTableProps<T>['onRowMouseEnter'];
    onRowMouseLeave: InfiniteTableProps<T>['onRowMouseLeave'];
    repeatWrappedGroupRows: InfiniteTableProps<T>['repeatWrappedGroupRows'];
    wrapRowsHorizontally: InfiniteTableProps<T>['wrapRowsHorizontally'];
    rowDetailCache: RowDetailCache<RowDetailCacheKey, RowDetailCacheEntry>;
    headerOptions: NonUndefined<InfiniteTableProps<T>['headerOptions']>;
    draggableColumnsRestrictTo: NonUndefined<InfiniteTableProps<T>['draggableColumnsRestrictTo']>;
    onScrollbarsChange: InfiniteTableProps<T>['onScrollbarsChange'];
    getContextMenuItems: InfiniteTableProps<T>['getContextMenuItems'];
    getCellContextMenuItems: InfiniteTableProps<T>['getCellContextMenuItems'];
    getColumnMenuItems: InfiniteTableProps<T>['getColumnMenuItems'];
    getFilterOperatorMenuItems: InfiniteTableProps<T>['getFilterOperatorMenuItems'];
    keyboardShortcuts: InfiniteTableProps<T>['keyboardShortcuts'];
    columnPinning: InfiniteTablePropColumnPinning;
    loadingText: InfiniteTableProps<T>['loadingText'];
    components: InfiniteTableProps<T>['components'];
    columns: InfiniteTablePropColumns<T>;
    pivotColumns: InfiniteTableProps<T>['pivotColumns'];
    onReady: InfiniteTableProps<T>['onReady'];
    onContextMenu: InfiniteTableProps<T>['onContextMenu'];
    onCellContextMenu: InfiniteTableProps<T>['onCellContextMenu'];
    onSelfFocus: InfiniteTableProps<T>['onSelfFocus'];
    onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
    onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
    onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
    onEditCancelled: InfiniteTableProps<T>['onEditCancelled'];
    onEditRejected: InfiniteTableProps<T>['onEditRejected'];
    onEditAccepted: InfiniteTableProps<T>['onEditAccepted'];
    shouldAcceptEdit: InfiniteTableProps<T>['shouldAcceptEdit'];
    persistEdit: InfiniteTableProps<T>['persistEdit'];
    onEditPersistSuccess: InfiniteTableProps<T>['onEditPersistSuccess'];
    onEditPersistError: InfiniteTableProps<T>['onEditPersistError'];
    autoSizeColumnsKey: InfiniteTableProps<T>['autoSizeColumnsKey'];
    activeRowIndex: InfiniteTableProps<T>['activeRowIndex'];
    activeCellIndex: InfiniteTableProps<T>['activeCellIndex'];
    onRenderRangeChange: InfiniteTableProps<T>['onRenderRangeChange'];
    scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
    onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
    onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
    onScrollStop: InfiniteTableProps<T>['onScrollStop'];
    scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
    focusedClassName: InfiniteTableProps<T>['focusedClassName'];
    focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
    focusedStyle: InfiniteTableProps<T>['focusedStyle'];
    focusedWithinStyle: InfiniteTableProps<T>['focusedWithinStyle'];
    showSeparatePivotColumnForSingleAggregation: NonUndefined<InfiniteTableProps<T>['showSeparatePivotColumnForSingleAggregation']>;
    domProps: InfiniteTableProps<T>['domProps'];
    editable: InfiniteTableProps<T>['editable'];
    columnMenuRealignDelay: NonUndefined<InfiniteTableProps<T>['columnMenuRealignDelay']>;
    columnDefaultEditable: InfiniteTableProps<T>['columnDefaultEditable'];
    columnDefaultFilterable: InfiniteTableProps<T>['columnDefaultFilterable'];
    columnDefaultSortable: InfiniteTableProps<T>['columnDefaultSortable'];
    rowStyle: InfiniteTableProps<T>['rowStyle'];
    cellStyle: InfiniteTableProps<T>['cellStyle'];
    rowProps: InfiniteTableProps<T>['rowProps'];
    rowClassName: InfiniteTableProps<T>['rowClassName'];
    cellClassName: InfiniteTableProps<T>['cellClassName'];
    pinnedStartMaxWidth: InfiniteTableProps<T>['pinnedStartMaxWidth'];
    pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
    pivotColumn: InfiniteTableProps<T>['pivotColumn'];
    pivotColumnGroups: InfiniteTablePropColumnGroups;
    columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
    columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
    columnDefaultWidth: NonUndefined<InfiniteTableProps<T>['columnDefaultWidth']>;
    columnDefaultFlex: InfiniteTableProps<T>['columnDefaultFlex'];
    columnCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnCssEllipsis']>;
    draggableColumns: InfiniteTableProps<T>['draggableColumns'];
    columnDefaultDraggable: InfiniteTableProps<T>['columnDefaultDraggable'];
    sortable: InfiniteTableProps<T>['sortable'];
    hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
    hideColumnWhenGrouped: NonUndefined<InfiniteTableProps<T>['hideColumnWhenGrouped']>;
    keyboardSelection: NonUndefined<InfiniteTableProps<T>['keyboardSelection']>;
    columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
    showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
    showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
    header: NonUndefined<InfiniteTableProps<T>['header']>;
    virtualizeColumns: NonUndefined<InfiniteTableProps<T>['virtualizeColumns']>;
    rowHeight: number | ((rowInfo: InfiniteTableRowInfo<T>) => number);
    rowDetailHeight: number | ((rowInfo: InfiniteTableRowInfo<T>) => number);
    columnHeaderHeight: number;
    licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
    columnVisibility: InfiniteTablePropColumnVisibility;
    columnGroupVisibility: NonUndefined<InfiniteTableProps<T>['columnGroupVisibility']>;
    columnSizing: InfiniteTablePropColumnSizing;
    columnTypes: InfiniteTablePropColumnTypes<T>;
    columnGroups: InfiniteTablePropColumnGroups;
    collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
    pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
    pivotGrandTotalColumnPosition: InfiniteTableProps<T>['pivotGrandTotalColumnPosition'];
}
interface InfiniteTableDerivedState<T> {
    isTree: boolean;
    groupBy: DataSourceProps<T>['groupBy'];
    computedColumns: Record<string, InfiniteTableColumn<T>>;
    initialColumns: InfiniteTableProps<T>['columns'];
    rowDetailState: RowDetailState<T> | undefined;
    isRowDetailExpanded: InfiniteTableProps<T>['isRowDetailExpanded'] | undefined;
    rowDetailRenderer?: InfiniteTableProps<T>['rowDetailRenderer'];
    isRowDetailEnabled: NonUndefined<InfiniteTableProps<T>['isRowDetailEnabled']> | boolean;
    showColumnFilters: NonUndefined<InfiniteTableProps<T>['showColumnFilters']>;
    groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
    columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
    keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>;
    columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
    columnGroupsMaxDepth: number;
    computedColumnGroups: InfiniteTablePropColumnGroups;
    rowHeightCSSVar: string;
    rowDetailHeightCSSVar: string;
    columnHeaderHeightCSSVar: string;
    controlledColumnVisibility: boolean;
}
type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
}

type CellPositionOptions = {
    rowIndex: number;
    colIndex: number;
    rowId?: never;
    colId?: never;
} | {
    rowIndex?: never;
    colIndex?: never;
    rowId: any;
    colId: string;
} | {
    rowIndex: number;
    colIndex?: never;
    rowId?: never;
    colId: string;
} | {
    rowIndex?: never;
    colIndex: number;
    rowId: any;
    colId?: never;
};

type InfiniteTableCellSelectionApi<T> = {
    isCellSelected(cellPosition: CellPositionOptions): boolean;
    selectCell(cellPosition: CellPositionOptions & {
        clear?: boolean;
    }): void;
    deselectCell(cellPosition: CellPositionOptions): void;
    deselectAll(): void;
    clear(): void;
    selectAll(): void;
    selectColumn(colId: string, options?: {
        clear?: boolean;
    }): void;
    deselectColumn(colId: string): void;
    selectRange(start: CellPositionOptions, end: CellPositionOptions): void;
    deselectRange(start: CellPositionOptions, end: CellPositionOptions): void;
    getAllCellSelectionPositions(): {
        columnIds: string[];
        positions: (CellSelectionPosition | null)[][];
    };
    mapCellSelectionPositions<SELECTED_VALUE, EMPTY_VALUE>(fn: (rowInfo: InfiniteTableRowInfo<T>, colId: string) => SELECTED_VALUE, emptyValue: EMPTY_VALUE): {
        columnIds: string[];
        positions: (SELECTED_VALUE | EMPTY_VALUE)[][];
    };
};

type CellNavigationConfig = {
    direction: 'top' | 'bottom' | 'left' | 'right';
};
interface InfiniteTableKeyboardNavigationApi<T> {
    setKeyboardNavigation: (keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>) => void;
    setActiveCellIndex: (activeCellIndex: NonUndefined<InfiniteTableProps<T>['activeCellIndex']>) => void;
    setActiveRowIndex: (activeRowIndex: NonUndefined<InfiniteTableProps<T>['activeRowIndex']>) => void;
    gotoNextRow: () => number | false;
    gotoPreviousRow: () => number | false;
    gotoRow: (direction: 1 | -1) => number | false;
    gotoCell: (config: CellNavigationConfig) => false | [number, number];
}

type InfiniteTableRowDetailApi = {
    isRowDetailExpanded(pk: any): boolean;
    isRowDetailCollapsed(pk: any): boolean;
    expandRowDetail(pk: any): void;
    collapseRowDetail(pk: any): void;
    toggleRowDetail(pk: any): void;
    collapseAllDetails(): void;
    expandAllDetails(): void;
    isRowDetailEnabledForRow(pk: any): boolean;
};

type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
type InfiniteTableRowSelectionApi = {
    get allRowsSelected(): boolean;
    isRowSelected(pk: any, groupKeys?: any[]): boolean;
    isRowDeselected(pk: any, groupKeys?: any[]): boolean;
    selectRow(pk: any, groupKeys?: any[]): void;
    deselectRow(pk: any, groupKeys?: any[]): void;
    toggleRowSelection(pk: any, groupKeys?: any[]): void;
    selectGroupRow(groupKeys: any[], children?: ArrayOfIds): void;
    deselectGroupRow(groupKeys: any[], children?: ArrayOfIds): void;
    toggleGroupRowSelection(groupKeys: any[], children?: ArrayOfIds): void;
    getGroupRowSelectionState(groupKeys: any[]): boolean | null;
    getSelectedPrimaryKeys(rowSelection?: RowSelectionStateObject): (string | number)[];
    selectAll(): void;
    deselectAll(): void;
};

declare enum InfiniteTableActionType {
    SET_COLUMN_SIZE = 0,
    SET_SCROLL_POSITION = 1,
    SET_BODY_SIZE = 2,
    SET_COLUMN_ORDER = 3,
    SET_COLUMN_VISIBILITY = 4,
    SET_COLUMN_SHIFTS = 5,
    SET_COLUMN_PINNING = 6,
    SET_COLUMN_AGGREGATIONS = 7,
    SET_DRAGGING_COLUMN_ID = 8
}

type InfiniteTableAction = {
    type: InfiniteTableActionType;
    payload?: any;
};

declare class RowSizeCache {
    rowHeight: Map<number, number>;
    rowDetailHeight: Map<number, number>;
    getTotalRowHeight(index: number): number;
    getRowHeight: (index: number) => number;
    getRowDetailHeight: (index: number) => number;
    getSize(index: number): {
        rowHeight: number;
        rowDetailHeight: number;
        totalRowHeight: number;
    };
}

type MultiCellSelectorOptions = {
    getPrimaryKeyByIndex: (rowIndex: number) => string | number;
    getColumnIdByIndex: (colIndex: number) => string;
};
declare class MultiCellSelector {
    multiSelectStartPosition: CellPositionByIndex;
    multiSelectEndPosition?: CellPositionByIndex;
    getPrimaryKeyByIndex: MultiCellSelectorOptions['getPrimaryKeyByIndex'];
    getColumnIdByIndex: MultiCellSelectorOptions['getColumnIdByIndex'];
    _cellSelectionState: CellSelectionState;
    constructor(options: MultiCellSelectorOptions);
    private getCellSelectionPosition;
    set cellSelectionState(cellSelectionState: CellSelectionState);
    get cellSelectionState(): CellSelectionState;
    /**
     * This is the single click, without any modifier
     */
    resetClick(position: CellPositionByIndex): void;
    /**
     * This is the click with ctrl/cmd key pressed
     * @param position CellPosition
     */
    singleAddClick(position: CellPositionByIndex): void;
    multiSelectClick(position: CellPositionByIndex, options: MultiSelectRangeOptions): void;
    setRangeSelected(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, selected: boolean, options: MultiSelectRangeOptions): void;
    deselectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
    selectRange(startPosition: CellPositionByIndex, endPosition: CellPositionByIndex, options: MultiSelectRangeOptions): void;
}

type MultiRowSelectorOptions = {
    getIdForIndex: (index: number) => string | number;
    isRowDisabledAt: (index: number) => boolean;
};
declare class MultiRowSelector {
    getIdForIndex: MultiRowSelectorOptions['getIdForIndex'];
    isRowDisabledAt: MultiRowSelectorOptions['isRowDisabledAt'];
    multiSelectStartIndex: number;
    multiSelectEndIndex?: number;
    _rowSelectionState: RowSelectionState;
    constructor(options: MultiRowSelectorOptions);
    set rowSelectionState(rowSelectionState: RowSelectionState);
    get rowSelectionState(): RowSelectionState;
    private selectRange;
    private deselectRange;
    /**
     * This is the single click, without any modifier
     */
    resetClick(index: number): void;
    /**
     * This is the click with ctrl/cmd key pressed
     * @param index
     */
    singleAddClick(index: number): void;
    multiSelectClick(index: number): void;
}

interface InfiniteTableComputedValues<T> {
    scrollbars: {
        vertical: boolean;
        horizontal: boolean;
    };
    multiRowSelector: MultiRowSelector;
    multiCellSelector: MultiCellSelector;
    computedRowHeight: number | ((index: number) => number);
    computedRowSizeCacheForDetails: RowSizeCache | undefined;
    renderSelectionCheckBox: boolean;
    rowspan?: MatrixBrainOptions['rowspan'];
    computedPinnedStartOverflow: boolean;
    computedPinnedEndOverflow: boolean;
    computedPinnedStartColumns: InfiniteTableComputedColumn<T>[];
    computedPinnedEndColumns: InfiniteTableComputedColumn<T>[];
    computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
    computedVisibleColumns: InfiniteTableComputedColumn<T>[];
    computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
    computedColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
    computedColumnsMapInInitialOrder: Map<string, InfiniteTableComputedColumn<T>>;
    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
    computedPinnedStartColumnsWidth: number;
    computedPinnedStartWidth: number;
    computedPinnedEndColumnsWidth: number;
    computedPinnedEndWidth: number;
    computedUnpinnedColumnsWidth: number;
    computedUnpinnedOffset: number;
    computedPinnedEndOffset: number;
    computedRemainingSpace: number;
    fieldsToColumn: Map<keyof T, InfiniteTableComputedColumn<T>>;
    toggleGroupRow: (groupKeys: any[]) => void;
    columnSize: (colIndex: number) => number;
}

type InfiniteTableEventHandlerContext<T> = {
    getComputed: () => InfiniteTableComputedValues<T>;
    getState: () => InfiniteTableState<T>;
    actions: InfiniteTableActions<T>;
    cloneRowSelection: (rowSelection: RowSelectionState<T>) => RowSelectionState<T>;
    cloneTreeSelection: (treeSelection: TreeSelectionState<T>) => TreeSelectionState<T>;
    getDataSourceState: () => DataSourceState<T>;
    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
    dataSourceActions: DataSourceComponentActions<T>;
    api: InfiniteTableApi<T>;
    dataSourceApi: DataSourceApi<T>;
};
type InfiniteTableKeyboardEventHandlerContext<T> = InfiniteTableEventHandlerContext<T>;
type InfiniteTableCellClickEventHandlerContext<T> = InfiniteTableEventHandlerContext<T> & {
    rowIndex: number;
    colIndex: number;
    column: InfiniteTableComputedColumn<T>;
    columnApi: InfiniteTableColumnApi<T>;
};

type OnCellClickContext<T> = InfiniteTableCellClickEventHandlerContext<T> & InfiniteTableKeyboardEventHandlerContext<T>;

interface InfiniteTableContextValue<T> {
    children?: React.ReactNode;
    api: InfiniteTableApi<T>;
    dataSourceApi: DataSourceApi<T>;
    state: InfiniteTableState<T>;
    actions: InfiniteTableActions<T>;
    dataSourceActions: DataSourceComponentActions<T>;
    computed: InfiniteTableComputedValues<T>;
    getComputed: () => InfiniteTableComputedValues<T>;
    getState: () => InfiniteTableState<T>;
    getDataSourceState: () => DataSourceState<T>;
    getDataSourceMasterContext: () => DataSourceMasterDetailContextValue | undefined;
}
interface InfiniteTablePublicContext<T> {
    api: InfiniteTableApi<T>;
    dataSourceApi: DataSourceApi<T>;
    getState: () => InfiniteTableState<T>;
    getDataSourceState: () => DataSourceState<T>;
}
type InfiniteTableRowContext<T> = InfiniteTablePublicContext<T> & InfiniteTableRowInfoDataDiscriminator<T> & {
    rowIndex: number;
};
interface InfiniteTableCellContext<T> {
    rowIndex: OnCellClickContext<T>['rowIndex'];
    colIndex: OnCellClickContext<T>['colIndex'];
    column: InfiniteTableComputedColumn<T>;
    columnApi: InfiniteTableColumnApi<T>;
}

type InfiniteTableBaseCellProps<T> = {
    column: InfiniteTableComputedColumn<T>;
    align?: InfiniteTableColumnAlignValues;
    horizontalLayoutPageIndex: number | null;
    rowId?: any;
    renderChildren: () => Renderable;
    width: number;
    cssEllipsis?: boolean;
    contentStyle?: CSSProperties;
    contentClassName?: string;
    virtualized?: boolean;
    skipColumnShifting?: boolean;
    beforeChildren?: Renderable;
    afterChildren?: Renderable;
    cssPosition?: CSSProperties['position'];
    domRef?: React.RefCallback<HTMLElement>;
};
type InfiniteTableCellProps<T> = ({
    cellType: 'header';
} & InfiniteTableBaseCellProps<T>) | ({
    cellType: 'body';
} & InfiniteTableBaseCellProps<T>);

declare function useInfiniteHeaderCell<T>(): {
    dragging: boolean;
    column: InfiniteTableComputedColumn<T>;
    columnsMap: Map<string, InfiniteTableComputedColumn<T>>;
    columnSortInfo: DataSourceSingleSortInfo<T> | null;
    columnFilterValue: DataSourceFilterValueItem<T> | null;
    selectionMode: DataSourcePropSelectionMode;
    horizontalLayoutPageIndex: null | number;
    allRowsSelected: boolean;
    someRowsSelected: boolean;
    filtered: boolean;
    api: InfiniteTableApi<T>;
    dataSourceApi: DataSourceApi<T>;
    columnApi: InfiniteTableColumnApi<T>;
    renderBag: {
        all?: Renderable;
        header: string | number | Renderable;
        sortIcon?: Renderable;
        menuIcon?: Renderable;
        menuIconProps?: MenuIconProps;
        filterIcon?: Renderable;
        filterEditor?: Renderable;
        selectionCheckBox?: Renderable;
    };
} & {
    domRef: InfiniteTableCellProps<DATA_TYPE>["domRef"];
    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
    insideColumnMenu: false;
} & {
    domRef: InfiniteTableCellProps<DATA_TYPE_1>["domRef"];
    htmlElementRef: React$1.MutableRefObject<HTMLElement | null>;
    insideColumnMenu: false;
};

declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
declare function useInfiniteColumnEditor<T>(): InfiniteColumnEditorContextType<T>;

declare function useInfiniteColumnFilterEditor<T>(): {
    api: InfiniteTableApi<T>;
    column: InfiniteTableComputedColumn<T>;
    columnFilterValue: DataSourceFilterValueItem<any> | null;
    columnApi: InfiniteTableColumnApi<T>;
    operatorName: string | undefined;
    operator: DataSourceFilterOperator<any> | undefined;
    value: any;
    disabled: boolean | undefined;
    filterType: DataSourceFilterType<any>;
    filterTypes: DataSourcePropFilterTypes<any>;
    filterTypeKey: string;
    filtered: boolean;
    setValue: (filterValue: any) => void;
    clearValue: () => void;
    removeColumnFilter: () => void;
    ariaLabel: string;
    className: string;
};

type HotKeyEventDescriptor = {
    key: KeyboardEvent['key'];
    metaKey: KeyboardEvent['metaKey'];
    altKey: KeyboardEvent['altKey'];
    ctrlKey: KeyboardEvent['ctrlKey'];
    shiftKey: KeyboardEvent['shiftKey'];
};
declare function eventMatchesKeyboardShortcut(event: HotKeyEventDescriptor, keyDescriptors: string | string[]): boolean;

declare function HScrollSyncContent(props: HTMLAttributes<HTMLDivElement> & {
    width?: 'viewport' | 'column';
    maxWidth?: 'viewport' | 'column';
    minWidth?: 'viewport' | 'column';
    scrollable?: boolean;
}): React$1.JSX.Element;

declare function useGridScroll(onScroll: (scrollPosition: ScrollPosition) => void, deps: any[]): void;

declare function useVisibleColumnSizes(): {
    id: string;
    width: number;
    cssVarForWidth: string;
    offset: number;
    cssVarForOffset: string;
    pinned: InfiniteTableColumnPinnedValues;
}[];

declare function useInfinitePortalContainer(): HTMLDivElement | null;

declare const InfiniteTableClassName: string;
declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => React$1.JSX.Element)>;
type InfiniteTableComponent = {
    <T>(props: InfiniteTableProps<T>): React$1.JSX.Element;
    licenseKey?: string;
    Header: () => React$1.JSX.Element | null;
    Body: () => React$1.JSX.Element | null;
    Footer: () => React$1.JSX.Element | null;
    HScrollSyncContent: typeof HScrollSyncContent;
};
declare const InfiniteTable: InfiniteTableComponent;

type DataSourceStateRestoreForDetail<T> = {
    originalDataArray: DataSourceState<T>['originalDataArray'] | undefined;
    groupBy: DataSourceState<T>['groupBy'] | undefined;
    groupRowsState: DataSourceState<T>['groupRowsState'] | undefined;
    pivotBy: DataSourceState<T>['pivotBy'] | undefined;
    sortInfo: DataSourceState<T>['sortInfo'] | undefined;
    filterValue: DataSourceState<T>['filterValue'] | undefined;
    livePaginationCursor: DataSourceState<T>['livePaginationCursor'] | undefined;
};
type RowDetailCacheKey = string | number;
type RowDetailCacheEntry = {
    all?: boolean;
    groupBy?: boolean;
    sortInfo?: boolean;
    filterValue?: boolean;
    data?: boolean;
    livePaginationCursor?: boolean;
    columnOrder?: boolean;
};

declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;

declare function useDataSourceState<T>(): DataSourceState<T>;

type FilterDataSourceParams<T> = {
    dataArray: T[];
    operatorsByFilterType: DataSourceDerivedState<T>['operatorsByFilterType'];
    filterTypes: DataSourcePropFilterTypes<T>;
    filterFunction?: DataSourcePropFilterFunction<T>;
    filterValue?: DataSourcePropFilterValue<T>;
    toPrimaryKey: (data: T, index: number) => any;
    treeFilterFunction: undefined | DataSourcePropTreeFilterFunction<T>;
    isLeafNode: undefined | ((item: T) => boolean);
    getNodeChildren: undefined | ((item: T) => null | T[]);
    nodesKey: string | undefined;
};
declare function filterDataArray<T>(params: FilterDataSourceParams<T>): T[];

declare const useManagedDataSource: (props: object) => {
    contextValue: {
        componentState: {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        };
        componentActions: ComponentStateGeneratedActions<{
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        }>;
        getComponentState: () => {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        };
        replaceState: (newState: {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        }) => void;
        assignState: (newState: Partial<{
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        } & {
            logger: DebugLogger;
            forceRerenderTimestamp: number;
            devToolsDetected: never;
            debugTimings: Map<DebugTimingKey, number>;
            debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
            indexer: Indexer<unknown, any>;
            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
            __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
            lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
            lastExpandStateInfoRef: React$1.MutableRefObject<{
                state: "collapsed" | "expanded";
                nodePath: NodePath$1 | null;
            }>;
            waitForNodePathPromises: DeepMap<any, {
                timestamp: number;
                promise: Promise<boolean>;
                resolve: (value: boolean) => void;
            }>;
            repeatWrappedGroupRows: never;
            rowsPerPage: never;
            totalLeafNodesCount: number;
            destroyedRef: React$1.MutableRefObject<boolean>;
            idToIndexMap: Map<any, number>;
            idToPathMap: Map<any, NodePath$1>;
            pathToIndexMap: DeepMap<any, number>;
            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
            treeSelectionState?: never;
            stateReadyAsDetails: never;
            cache?: never;
            unfilteredCount: number;
            filteredCount: number;
            rowInfoReducerResults?: never;
            originalDataArrayChanged: never;
            originalDataArrayChangedInfo: {
                timestamp: number;
                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
                treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
            };
            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
            pivotMappings?: never;
            propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
            showSeparatePivotColumnForSingleAggregation: never;
            dataParams?: never;
            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
            originalLazyGroupDataChangeDetect: never;
            scrollStopDelayUpdatedByTable: number;
            onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
            notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
            notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
            notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
            originalDataArray: unknown[];
            lastFilterDataArray?: never;
            lastSortDataArray?: never;
            lastGroupDataArray?: never;
            lastTreeDataArray?: never;
            dataArray: InfiniteTableRowInfo<unknown>[];
            groupDeepMap?: never;
            treeDeepMap?: never;
            treePaths?: never;
            groupRowsIndexesInDataArray?: never;
            reducerResults?: never;
            allRowsSelected: never;
            someRowsSelected: never;
            pivotTotalColumnPosition: never;
            pivotGrandTotalColumnPosition: never;
            cursorId: never;
            updatedAt: number;
            reducedAt: number;
            groupedAt: number;
            treeAt: number;
            sortedAt: number;
            filteredAt: number;
            generateGroupRows: never;
            postFilterDataArray?: never;
            postSortDataArray?: never;
            postGroupDataArray?: never;
            pivotColumns?: never;
            pivotColumnGroups?: never;
            debugId: never;
            isTree: never;
            toPrimaryKey: (data: unknown) => any;
            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
            sortMode: never;
            filterMode: never;
            groupMode: never;
            pivotMode: never;
            shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
            groupRowsState: GroupRowsState<unknown>;
            treeExpandState: TreeExpandState<any>;
            treeExpandMode: never;
            multiSort: never;
            controlledSort: never;
            controlledFilter: never;
            livePaginationCursor?: never;
            lazyLoadBatchSize?: never;
            rowSelection: never;
            isRowDisabled: never;
            cellSelection: never;
            selectionMode: never;
            aggregationReducers?: never;
            livePagination: never;
            refetchKey: never;
            isRowSelected: never;
            isNodeSelected: never;
            isNodeExpanded: never;
            isNodeCollapsed: never;
            isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
            isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
            onNodeCollapse: never;
            onNodeExpand: never;
            nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
            treeSelection: never;
            batchOperationDelay: never;
            onDataArrayChange: never;
            onDataMutations: never;
            onTreeDataMutations: never;
            onReady: never;
            rowInfoReducers: never;
            lazyLoad: never;
            useGroupKeysForMultiRowSelection: never;
            onDataParamsChange: never;
            data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
            sortFunction: never;
            filterFunction: never;
            treeFilterFunction: never;
            filterValue: never;
            filterTypes: DataSourcePropFilterTypes<unknown>;
            primaryKey: (data: unknown) => string;
            filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
            groupBy: DataSourcePropGroupBy<unknown>;
            pivotBy: never;
            loading: never;
            sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
            collapseGroupRowsOnDataFunctionChange: never;
            sortInfo: never;
            rowDisabledState: never;
        }>) => void;
    };
    ContextComponent: React$1.Context<ManagedComponentStateContextValue<{
        logger: DebugLogger;
        forceRerenderTimestamp: number;
        devToolsDetected: never;
        debugTimings: Map<DebugTimingKey, number>;
        debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
        indexer: Indexer<unknown, any>;
        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
        lastExpandStateInfoRef: React$1.MutableRefObject<{
            state: "collapsed" | "expanded";
            nodePath: NodePath$1 | null;
        }>;
        waitForNodePathPromises: DeepMap<any, {
            timestamp: number;
            promise: Promise<boolean>;
            resolve: (value: boolean) => void;
        }>;
        repeatWrappedGroupRows: never;
        rowsPerPage: never;
        totalLeafNodesCount: number;
        destroyedRef: React$1.MutableRefObject<boolean>;
        idToIndexMap: Map<any, number>;
        idToPathMap: Map<any, NodePath$1>;
        pathToIndexMap: DeepMap<any, number>;
        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
        treeSelectionState?: never;
        stateReadyAsDetails: never;
        cache?: never;
        unfilteredCount: number;
        filteredCount: number;
        rowInfoReducerResults?: never;
        originalDataArrayChanged: never;
        originalDataArrayChangedInfo: {
            timestamp: number;
            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
        };
        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
        pivotMappings?: never;
        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
        showSeparatePivotColumnForSingleAggregation: never;
        dataParams?: never;
        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
        originalLazyGroupDataChangeDetect: never;
        scrollStopDelayUpdatedByTable: number;
        onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
        notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
        originalDataArray: unknown[];
        lastFilterDataArray?: never;
        lastSortDataArray?: never;
        lastGroupDataArray?: never;
        lastTreeDataArray?: never;
        dataArray: InfiniteTableRowInfo<unknown>[];
        groupDeepMap?: never;
        treeDeepMap?: never;
        treePaths?: never;
        groupRowsIndexesInDataArray?: never;
        reducerResults?: never;
        allRowsSelected: never;
        someRowsSelected: never;
        pivotTotalColumnPosition: never;
        pivotGrandTotalColumnPosition: never;
        cursorId: never;
        updatedAt: number;
        reducedAt: number;
        groupedAt: number;
        treeAt: number;
        sortedAt: number;
        filteredAt: number;
        generateGroupRows: never;
        postFilterDataArray?: never;
        postSortDataArray?: never;
        postGroupDataArray?: never;
        pivotColumns?: never;
        pivotColumnGroups?: never;
        debugId: never;
        isTree: never;
        toPrimaryKey: (data: unknown) => any;
        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
        sortMode: never;
        filterMode: never;
        groupMode: never;
        pivotMode: never;
        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
        groupRowsState: GroupRowsState<unknown>;
        treeExpandState: TreeExpandState<any>;
        treeExpandMode: never;
        multiSort: never;
        controlledSort: never;
        controlledFilter: never;
        livePaginationCursor?: never;
        lazyLoadBatchSize?: never;
        rowSelection: never;
        isRowDisabled: never;
        cellSelection: never;
        selectionMode: never;
        aggregationReducers?: never;
        livePagination: never;
        refetchKey: never;
        isRowSelected: never;
        isNodeSelected: never;
        isNodeExpanded: never;
        isNodeCollapsed: never;
        isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
        isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
        onNodeCollapse: never;
        onNodeExpand: never;
        nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
        treeSelection: never;
        batchOperationDelay: never;
        onDataArrayChange: never;
        onDataMutations: never;
        onTreeDataMutations: never;
        onReady: never;
        rowInfoReducers: never;
        lazyLoad: never;
        useGroupKeysForMultiRowSelection: never;
        onDataParamsChange: never;
        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
        sortFunction: never;
        filterFunction: never;
        treeFilterFunction: never;
        filterValue: never;
        filterTypes: DataSourcePropFilterTypes<unknown>;
        primaryKey: (data: unknown) => string;
        filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
        groupBy: DataSourcePropGroupBy<unknown>;
        pivotBy: never;
        loading: never;
        sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
        collapseGroupRowsOnDataFunctionChange: never;
        sortInfo: never;
        rowDisabledState: never;
    } & {
        logger: DebugLogger;
        forceRerenderTimestamp: number;
        devToolsDetected: never;
        debugTimings: Map<DebugTimingKey, number>;
        debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
        indexer: Indexer<unknown, any>;
        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
        lastExpandStateInfoRef: React$1.MutableRefObject<{
            state: "collapsed" | "expanded";
            nodePath: NodePath$1 | null;
        }>;
        waitForNodePathPromises: DeepMap<any, {
            timestamp: number;
            promise: Promise<boolean>;
            resolve: (value: boolean) => void;
        }>;
        repeatWrappedGroupRows: never;
        rowsPerPage: never;
        totalLeafNodesCount: number;
        destroyedRef: React$1.MutableRefObject<boolean>;
        idToIndexMap: Map<any, number>;
        idToPathMap: Map<any, NodePath$1>;
        pathToIndexMap: DeepMap<any, number>;
        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
        treeSelectionState?: never;
        stateReadyAsDetails: never;
        cache?: never;
        unfilteredCount: number;
        filteredCount: number;
        rowInfoReducerResults?: never;
        originalDataArrayChanged: never;
        originalDataArrayChangedInfo: {
            timestamp: number;
            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
        };
        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
        pivotMappings?: never;
        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
        showSeparatePivotColumnForSingleAggregation: never;
        dataParams?: never;
        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
        originalLazyGroupDataChangeDetect: never;
        scrollStopDelayUpdatedByTable: number;
        onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
        notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
        originalDataArray: unknown[];
        lastFilterDataArray?: never;
        lastSortDataArray?: never;
        lastGroupDataArray?: never;
        lastTreeDataArray?: never;
        dataArray: InfiniteTableRowInfo<unknown>[];
        groupDeepMap?: never;
        treeDeepMap?: never;
        treePaths?: never;
        groupRowsIndexesInDataArray?: never;
        reducerResults?: never;
        allRowsSelected: never;
        someRowsSelected: never;
        pivotTotalColumnPosition: never;
        pivotGrandTotalColumnPosition: never;
        cursorId: never;
        updatedAt: number;
        reducedAt: number;
        groupedAt: number;
        treeAt: number;
        sortedAt: number;
        filteredAt: number;
        generateGroupRows: never;
        postFilterDataArray?: never;
        postSortDataArray?: never;
        postGroupDataArray?: never;
        pivotColumns?: never;
        pivotColumnGroups?: never;
        debugId: never;
        isTree: never;
        toPrimaryKey: (data: unknown) => any;
        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
        sortMode: never;
        filterMode: never;
        groupMode: never;
        pivotMode: never;
        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
        groupRowsState: GroupRowsState<unknown>;
        treeExpandState: TreeExpandState<any>;
        treeExpandMode: never;
        multiSort: never;
        controlledSort: never;
        controlledFilter: never;
        livePaginationCursor?: never;
        lazyLoadBatchSize?: never;
        rowSelection: never;
        isRowDisabled: never;
        cellSelection: never;
        selectionMode: never;
        aggregationReducers?: never;
        livePagination: never;
        refetchKey: never;
        isRowSelected: never;
        isNodeSelected: never;
        isNodeExpanded: never;
        isNodeCollapsed: never;
        isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
        isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
        onNodeCollapse: never;
        onNodeExpand: never;
        nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
        treeSelection: never;
        batchOperationDelay: never;
        onDataArrayChange: never;
        onDataMutations: never;
        onTreeDataMutations: never;
        onReady: never;
        rowInfoReducers: never;
        lazyLoad: never;
        useGroupKeysForMultiRowSelection: never;
        onDataParamsChange: never;
        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
        sortFunction: never;
        filterFunction: never;
        treeFilterFunction: never;
        filterValue: never;
        filterTypes: DataSourcePropFilterTypes<unknown>;
        primaryKey: (data: unknown) => string;
        filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
        groupBy: DataSourcePropGroupBy<unknown>;
        pivotBy: never;
        loading: never;
        sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
        collapseGroupRowsOnDataFunctionChange: never;
        sortInfo: never;
        rowDisabledState: never;
    } & {
        logger: DebugLogger;
        forceRerenderTimestamp: number;
        devToolsDetected: never;
        debugTimings: Map<DebugTimingKey, number>;
        debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
        indexer: Indexer<unknown, any>;
        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
        lastExpandStateInfoRef: React$1.MutableRefObject<{
            state: "collapsed" | "expanded";
            nodePath: NodePath$1 | null;
        }>;
        waitForNodePathPromises: DeepMap<any, {
            timestamp: number;
            promise: Promise<boolean>;
            resolve: (value: boolean) => void;
        }>;
        repeatWrappedGroupRows: never;
        rowsPerPage: never;
        totalLeafNodesCount: number;
        destroyedRef: React$1.MutableRefObject<boolean>;
        idToIndexMap: Map<any, number>;
        idToPathMap: Map<any, NodePath$1>;
        pathToIndexMap: DeepMap<any, number>;
        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
        treeSelectionState?: never;
        stateReadyAsDetails: never;
        cache?: never;
        unfilteredCount: number;
        filteredCount: number;
        rowInfoReducerResults?: never;
        originalDataArrayChanged: never;
        originalDataArrayChangedInfo: {
            timestamp: number;
            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
        };
        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
        pivotMappings?: never;
        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
        showSeparatePivotColumnForSingleAggregation: never;
        dataParams?: never;
        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
        originalLazyGroupDataChangeDetect: never;
        scrollStopDelayUpdatedByTable: number;
        onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
        notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
        originalDataArray: unknown[];
        lastFilterDataArray?: never;
        lastSortDataArray?: never;
        lastGroupDataArray?: never;
        lastTreeDataArray?: never;
        dataArray: InfiniteTableRowInfo<unknown>[];
        groupDeepMap?: never;
        treeDeepMap?: never;
        treePaths?: never;
        groupRowsIndexesInDataArray?: never;
        reducerResults?: never;
        allRowsSelected: never;
        someRowsSelected: never;
        pivotTotalColumnPosition: never;
        pivotGrandTotalColumnPosition: never;
        cursorId: never;
        updatedAt: number;
        reducedAt: number;
        groupedAt: number;
        treeAt: number;
        sortedAt: number;
        filteredAt: number;
        generateGroupRows: never;
        postFilterDataArray?: never;
        postSortDataArray?: never;
        postGroupDataArray?: never;
        pivotColumns?: never;
        pivotColumnGroups?: never;
        debugId: never;
        isTree: never;
        toPrimaryKey: (data: unknown) => any;
        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
        sortMode: never;
        filterMode: never;
        groupMode: never;
        pivotMode: never;
        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
        groupRowsState: GroupRowsState<unknown>;
        treeExpandState: TreeExpandState<any>;
        treeExpandMode: never;
        multiSort: never;
        controlledSort: never;
        controlledFilter: never;
        livePaginationCursor?: never;
        lazyLoadBatchSize?: never;
        rowSelection: never;
        isRowDisabled: never;
        cellSelection: never;
        selectionMode: never;
        aggregationReducers?: never;
        livePagination: never;
        refetchKey: never;
        isRowSelected: never;
        isNodeSelected: never;
        isNodeExpanded: never;
        isNodeCollapsed: never;
        isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
        isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
        onNodeCollapse: never;
        onNodeExpand: never;
        nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
        treeSelection: never;
        batchOperationDelay: never;
        onDataArrayChange: never;
        onDataMutations: never;
        onTreeDataMutations: never;
        onReady: never;
        rowInfoReducers: never;
        lazyLoad: never;
        useGroupKeysForMultiRowSelection: never;
        onDataParamsChange: never;
        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
        sortFunction: never;
        filterFunction: never;
        treeFilterFunction: never;
        filterValue: never;
        filterTypes: DataSourcePropFilterTypes<unknown>;
        primaryKey: (data: unknown) => string;
        filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
        groupBy: DataSourcePropGroupBy<unknown>;
        pivotBy: never;
        loading: never;
        sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
        collapseGroupRowsOnDataFunctionChange: never;
        sortInfo: never;
        rowDisabledState: never;
    }, ComponentStateGeneratedActions<{
        logger: DebugLogger;
        forceRerenderTimestamp: number;
        devToolsDetected: never;
        debugTimings: Map<DebugTimingKey, number>;
        debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
        indexer: Indexer<unknown, any>;
        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
        lastExpandStateInfoRef: React$1.MutableRefObject<{
            state: "collapsed" | "expanded";
            nodePath: NodePath$1 | null;
        }>;
        waitForNodePathPromises: DeepMap<any, {
            timestamp: number;
            promise: Promise<boolean>;
            resolve: (value: boolean) => void;
        }>;
        repeatWrappedGroupRows: never;
        rowsPerPage: never;
        totalLeafNodesCount: number;
        destroyedRef: React$1.MutableRefObject<boolean>;
        idToIndexMap: Map<any, number>;
        idToPathMap: Map<any, NodePath$1>;
        pathToIndexMap: DeepMap<any, number>;
        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
        treeSelectionState?: never;
        stateReadyAsDetails: never;
        cache?: never;
        unfilteredCount: number;
        filteredCount: number;
        rowInfoReducerResults?: never;
        originalDataArrayChanged: never;
        originalDataArrayChangedInfo: {
            timestamp: number;
            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
        };
        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
        pivotMappings?: never;
        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
        showSeparatePivotColumnForSingleAggregation: never;
        dataParams?: never;
        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
        originalLazyGroupDataChangeDetect: never;
        scrollStopDelayUpdatedByTable: number;
        onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
        notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
        originalDataArray: unknown[];
        lastFilterDataArray?: never;
        lastSortDataArray?: never;
        lastGroupDataArray?: never;
        lastTreeDataArray?: never;
        dataArray: InfiniteTableRowInfo<unknown>[];
        groupDeepMap?: never;
        treeDeepMap?: never;
        treePaths?: never;
        groupRowsIndexesInDataArray?: never;
        reducerResults?: never;
        allRowsSelected: never;
        someRowsSelected: never;
        pivotTotalColumnPosition: never;
        pivotGrandTotalColumnPosition: never;
        cursorId: never;
        updatedAt: number;
        reducedAt: number;
        groupedAt: number;
        treeAt: number;
        sortedAt: number;
        filteredAt: number;
        generateGroupRows: never;
        postFilterDataArray?: never;
        postSortDataArray?: never;
        postGroupDataArray?: never;
        pivotColumns?: never;
        pivotColumnGroups?: never;
        debugId: never;
        isTree: never;
        toPrimaryKey: (data: unknown) => any;
        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
        sortMode: never;
        filterMode: never;
        groupMode: never;
        pivotMode: never;
        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
        groupRowsState: GroupRowsState<unknown>;
        treeExpandState: TreeExpandState<any>;
        treeExpandMode: never;
        multiSort: never;
        controlledSort: never;
        controlledFilter: never;
        livePaginationCursor?: never;
        lazyLoadBatchSize?: never;
        rowSelection: never;
        isRowDisabled: never;
        cellSelection: never;
        selectionMode: never;
        aggregationReducers?: never;
        livePagination: never;
        refetchKey: never;
        isRowSelected: never;
        isNodeSelected: never;
        isNodeExpanded: never;
        isNodeCollapsed: never;
        isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
        isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
        onNodeCollapse: never;
        onNodeExpand: never;
        nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
        treeSelection: never;
        batchOperationDelay: never;
        onDataArrayChange: never;
        onDataMutations: never;
        onTreeDataMutations: never;
        onReady: never;
        rowInfoReducers: never;
        lazyLoad: never;
        useGroupKeysForMultiRowSelection: never;
        onDataParamsChange: never;
        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
        sortFunction: never;
        filterFunction: never;
        treeFilterFunction: never;
        filterValue: never;
        filterTypes: DataSourcePropFilterTypes<unknown>;
        primaryKey: (data: unknown) => string;
        filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
        groupBy: DataSourcePropGroupBy<unknown>;
        pivotBy: never;
        loading: never;
        sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
        collapseGroupRowsOnDataFunctionChange: never;
        sortInfo: never;
        rowDisabledState: never;
    } & {
        logger: DebugLogger;
        forceRerenderTimestamp: number;
        devToolsDetected: never;
        debugTimings: Map<DebugTimingKey, number>;
        debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
        indexer: Indexer<unknown, any>;
        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
        lastExpandStateInfoRef: React$1.MutableRefObject<{
            state: "collapsed" | "expanded";
            nodePath: NodePath$1 | null;
        }>;
        waitForNodePathPromises: DeepMap<any, {
            timestamp: number;
            promise: Promise<boolean>;
            resolve: (value: boolean) => void;
        }>;
        repeatWrappedGroupRows: never;
        rowsPerPage: never;
        totalLeafNodesCount: number;
        destroyedRef: React$1.MutableRefObject<boolean>;
        idToIndexMap: Map<any, number>;
        idToPathMap: Map<any, NodePath$1>;
        pathToIndexMap: DeepMap<any, number>;
        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
        treeSelectionState?: never;
        stateReadyAsDetails: never;
        cache?: never;
        unfilteredCount: number;
        filteredCount: number;
        rowInfoReducerResults?: never;
        originalDataArrayChanged: never;
        originalDataArrayChangedInfo: {
            timestamp: number;
            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
        };
        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
        pivotMappings?: never;
        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
        showSeparatePivotColumnForSingleAggregation: never;
        dataParams?: never;
        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
        originalLazyGroupDataChangeDetect: never;
        scrollStopDelayUpdatedByTable: number;
        onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
        notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
        originalDataArray: unknown[];
        lastFilterDataArray?: never;
        lastSortDataArray?: never;
        lastGroupDataArray?: never;
        lastTreeDataArray?: never;
        dataArray: InfiniteTableRowInfo<unknown>[];
        groupDeepMap?: never;
        treeDeepMap?: never;
        treePaths?: never;
        groupRowsIndexesInDataArray?: never;
        reducerResults?: never;
        allRowsSelected: never;
        someRowsSelected: never;
        pivotTotalColumnPosition: never;
        pivotGrandTotalColumnPosition: never;
        cursorId: never;
        updatedAt: number;
        reducedAt: number;
        groupedAt: number;
        treeAt: number;
        sortedAt: number;
        filteredAt: number;
        generateGroupRows: never;
        postFilterDataArray?: never;
        postSortDataArray?: never;
        postGroupDataArray?: never;
        pivotColumns?: never;
        pivotColumnGroups?: never;
        debugId: never;
        isTree: never;
        toPrimaryKey: (data: unknown) => any;
        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
        sortMode: never;
        filterMode: never;
        groupMode: never;
        pivotMode: never;
        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
        groupRowsState: GroupRowsState<unknown>;
        treeExpandState: TreeExpandState<any>;
        treeExpandMode: never;
        multiSort: never;
        controlledSort: never;
        controlledFilter: never;
        livePaginationCursor?: never;
        lazyLoadBatchSize?: never;
        rowSelection: never;
        isRowDisabled: never;
        cellSelection: never;
        selectionMode: never;
        aggregationReducers?: never;
        livePagination: never;
        refetchKey: never;
        isRowSelected: never;
        isNodeSelected: never;
        isNodeExpanded: never;
        isNodeCollapsed: never;
        isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
        isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
        onNodeCollapse: never;
        onNodeExpand: never;
        nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
        treeSelection: never;
        batchOperationDelay: never;
        onDataArrayChange: never;
        onDataMutations: never;
        onTreeDataMutations: never;
        onReady: never;
        rowInfoReducers: never;
        lazyLoad: never;
        useGroupKeysForMultiRowSelection: never;
        onDataParamsChange: never;
        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
        sortFunction: never;
        filterFunction: never;
        treeFilterFunction: never;
        filterValue: never;
        filterTypes: DataSourcePropFilterTypes<unknown>;
        primaryKey: (data: unknown) => string;
        filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
        groupBy: DataSourcePropGroupBy<unknown>;
        pivotBy: never;
        loading: never;
        sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
        collapseGroupRowsOnDataFunctionChange: never;
        sortInfo: never;
        rowDisabledState: never;
    } & {
        logger: DebugLogger;
        forceRerenderTimestamp: number;
        devToolsDetected: never;
        debugTimings: Map<DebugTimingKey, number>;
        debugWarnings: Map<DataSourceDebugWarningKey, DebugWarningPayload>;
        indexer: Indexer<unknown, any>;
        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue | undefined>;
        __apiRef: React$1.MutableRefObject<DataSourceApi<unknown> | null>;
        lastSelectionUpdatedNodePathRef: React$1.MutableRefObject<NodePath$1 | null>;
        lastExpandStateInfoRef: React$1.MutableRefObject<{
            state: "collapsed" | "expanded";
            nodePath: NodePath$1 | null;
        }>;
        waitForNodePathPromises: DeepMap<any, {
            timestamp: number;
            promise: Promise<boolean>;
            resolve: (value: boolean) => void;
        }>;
        repeatWrappedGroupRows: never;
        rowsPerPage: never;
        totalLeafNodesCount: number;
        destroyedRef: React$1.MutableRefObject<boolean>;
        idToIndexMap: Map<any, number>;
        idToPathMap: Map<any, NodePath$1>;
        pathToIndexMap: DeepMap<any, number>;
        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
        treeSelectionState?: never;
        stateReadyAsDetails: never;
        cache?: never;
        unfilteredCount: number;
        filteredCount: number;
        rowInfoReducerResults?: never;
        originalDataArrayChanged: never;
        originalDataArrayChangedInfo: {
            timestamp: number;
            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
            treeMutations?: DeepMap<any, DataSourceMutation<unknown>[]> | undefined;
        };
        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
        pivotMappings?: never;
        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
        showSeparatePivotColumnForSingleAggregation: never;
        dataParams?: never;
        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
        originalLazyGroupDataChangeDetect: never;
        scrollStopDelayUpdatedByTable: number;
        onCleanup: SubscriptionCallback<DataSourceState<unknown>>;
        notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
        originalDataArray: unknown[];
        lastFilterDataArray?: never;
        lastSortDataArray?: never;
        lastGroupDataArray?: never;
        lastTreeDataArray?: never;
        dataArray: InfiniteTableRowInfo<unknown>[];
        groupDeepMap?: never;
        treeDeepMap?: never;
        treePaths?: never;
        groupRowsIndexesInDataArray?: never;
        reducerResults?: never;
        allRowsSelected: never;
        someRowsSelected: never;
        pivotTotalColumnPosition: never;
        pivotGrandTotalColumnPosition: never;
        cursorId: never;
        updatedAt: number;
        reducedAt: number;
        groupedAt: number;
        treeAt: number;
        sortedAt: number;
        filteredAt: number;
        generateGroupRows: never;
        postFilterDataArray?: never;
        postSortDataArray?: never;
        postGroupDataArray?: never;
        pivotColumns?: never;
        pivotColumnGroups?: never;
        debugId: never;
        isTree: never;
        toPrimaryKey: (data: unknown) => any;
        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
        sortMode: never;
        filterMode: never;
        groupMode: never;
        pivotMode: never;
        shouldReloadData: Required<DataSourcePropShouldReloadDataObject<unknown>>;
        groupRowsState: GroupRowsState<unknown>;
        treeExpandState: TreeExpandState<any>;
        treeExpandMode: never;
        multiSort: never;
        controlledSort: never;
        controlledFilter: never;
        livePaginationCursor?: never;
        lazyLoadBatchSize?: never;
        rowSelection: never;
        isRowDisabled: never;
        cellSelection: never;
        selectionMode: never;
        aggregationReducers?: never;
        livePagination: never;
        refetchKey: never;
        isRowSelected: never;
        isNodeSelected: never;
        isNodeExpanded: never;
        isNodeCollapsed: never;
        isNodeReadOnly: DataSourcePropIsNodeReadOnly<unknown>;
        isNodeSelectable: DataSourcePropIsNodeSelectable<unknown>;
        onNodeCollapse: never;
        onNodeExpand: never;
        nodesKey: NonUndefined<TreeDataSourceProps<T_1>["nodesKey"]>;
        treeSelection: never;
        batchOperationDelay: never;
        onDataArrayChange: never;
        onDataMutations: never;
        onTreeDataMutations: never;
        onReady: never;
        rowInfoReducers: never;
        lazyLoad: never;
        useGroupKeysForMultiRowSelection: never;
        onDataParamsChange: never;
        data: (DataSourceData<unknown> & unknown[]) & DataSourceRemoteData<unknown> & Promise<unknown[] | DataSourceRemoteData<unknown>> & ((dataInfo: DataSourceDataParams<unknown>) => unknown[] | Promise<unknown[] | DataSourceRemoteData<unknown>>);
        sortFunction: never;
        filterFunction: never;
        treeFilterFunction: never;
        filterValue: never;
        filterTypes: DataSourcePropFilterTypes<unknown>;
        primaryKey: (data: unknown) => string;
        filterDelay: NonUndefined<DataSourceProps<T_1>["filterDelay"]>;
        groupBy: DataSourcePropGroupBy<unknown>;
        pivotBy: never;
        loading: never;
        sortTypes: NonUndefined<DataSourceProps<T_1>["sortTypes"]>;
        collapseGroupRowsOnDataFunctionChange: never;
        sortInfo: never;
        rowDisabledState: never;
    }>>>;
};
declare function DataSource<T>(props: DataSourceProps<T>): React$1.JSX.Element;
declare function useRowInfoReducers(): Record<string, any> | undefined;
declare function useMasterRowInfo<T = any>(): InfiniteTableRowInfo<T> | undefined;

type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
    id: string;
};
type AggregationReducerResult<AggregationResultType extends any = any> = AggregationResultType;
/**
 * InfiniteTableRowInfo can have different object shape depending on the presence or absence of grouping.
 *
 * You can use `dataSourceHasGrouping: boolean` as a discriminator to determine the shape of the object, to know
 * if the dataSource had grouping or not. Furthermore, for when the dataSource has grouping,
 * you can use `isGroupRow: boolean` to discriminate between group rows vs normal rows.
 *
 */
type InfiniteTableRowInfo<T> = InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T> | InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_Tree_RowInfoLeafNode<T> | InfiniteTable_Tree_RowInfoParentNode<T>;
type InfiniteTable_Tree_RowInfoLeafNode<T> = {
    dataSourceHasGrouping: false;
    isTreeNode: true;
    isParentNode: false;
    isGroupRow: false;
    data: T;
} & InfiniteTable_RowInfoBase<T> & InfiniteTable_Tree_RowInfoBase<T>;
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;
};
type InfiniteTable_Tree_RowInfoNode<T> = InfiniteTable_Tree_RowInfoLeafNode<T> | InfiniteTable_Tree_RowInfoParentNode<T>;
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>;
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>;
    field?: keyof T;
    value: any;
    rawValue: any;
    rowSelected: boolean | null;
};
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;
};
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;
};
type InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> = {
    rowActive: boolean;
    data: Partial<T> | null;
    rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<T>;
    rowDetailState: false | 'expanded' | 'collapsed';
    isGroupRow: true;
    isTreeNode: false;
    isParentNode: false;
    field?: keyof T;
    value: any;
    rawValue: any;
    rowSelected: boolean | null;
};
type InfiniteTableRowInfoDataDiscriminator<T> = InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> | InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> | InfiniteTableRowInfoDataDiscriminator_Node<T>;
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)
 *
 */
type InfiniteTable_RowInfoBase<_T> = {
    id: any;
    value?: any;
    indexInAll: number;
    rowSelected: boolean | null;
    rowDisabled: boolean;
    isCellSelected: (columnId: string) => boolean;
    hasSelectedCells: (columnIds: string[]) => boolean;
};
type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
    dataSourceHasGrouping: true;
    isTreeNode: false;
    data: T;
    isGroupRow: false;
} & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
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
     */
    deepRowInfoArray: (InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T>)[];
    error?: string;
    reducerResults?: Record<string, AggregationReducerResult>;
    /**
     * The count of all leaf nodes (normal rows) that are inside this group.
     * This count is the same as the length of the groupData array property.
     *
     */
    groupCount: number;
    /**
     * The array of all leaf nodes (normal rows) that are inside this group.
     */
    groupData: T[];
    /**
     * The count of all selected leaf nodes (normal rows) inside the group that are selected
     */
    selectedChildredCount: number;
    /**
     * The count of all deselected leaf nodes (normal rows) inside the group that are selected
     */
    deselectedChildredCount: number;
    /**
     * Will be used only with lazy loading, if the server provides this info on the data items.
     *
     * Represents the total count of all leaf nodes (normal rows) that are under this group
     * at any level (so not only direct children). This is needed for multiple selection to work properly,
     * so the table component knows how many rows are on the remote backend, and whether to show a group as selected or not
     * when it has a certain number of rows selected
     */
    totalChildrenCount?: number;
    /**
     * The count of all leaf nodes (normal rows) inside the group that are not being visible
     * due to collapsing (either the current row is collapsed or any of its children)
     */
    collapsedChildrenCount: number;
    collapsedGroupsCount: number;
    /**
     * The count of the direct children of the current group. Direct children can be either normal rows or groups.
     */
    directChildrenCount: number;
    directChildrenLoadedCount: number;
    /**
     *
     * A DeepMap of pivot values.
     *
     * For each pivot reducer result, it contains all the items that make up the pivot value.
     *
     */
    pivotValuesMap?: PivotValuesDeepMap<T, any>;
    /**
     * For non-lazy grouping, this is always true.
     * For lazy/batched grouping, this is true if the group has been expanded at least once (and if the remote call has been configured with cache: true),
     * since if the remote call is not cached, collapsing the row group should lose all the data that was loaded for it, and it's as if it was never loaded, so in that case, childrenAvailable is false.
     *
     * NOTE: if this is true, it doesn't mean that all the children have been loaded, it only means that some children have been loaded and are available
     *
     * Use directChildrenCount and directChildrenLoadedCount to know if all the children have been loaded or not.
     */
    childrenAvailable: boolean;
    /**
     * Boolean flag that will be true while lazy loading direct children of the current row group.
     *
     * NOTE: with batched loading, if the user is no longer scrolling, after everything
     * in the viewport has loaded (and thus for example a certain row group had childrenLoading: true)
     * if no new batches are being loaded, childrenLoading will be false again, even though
     * the current row group still has children that are not loaded yet.
     * Use directChildrenLoadedCount and directChildrenCount to know if all the children have been loaded or not.
     */
    childrenLoading: boolean;
} & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
type InfiniteTable_NoGrouping_RowInfoNormal<T> = {
    dataSourceHasGrouping: false;
    isTreeNode: false;
    data: T;
    isGroupRow: false;
    selfLoaded: boolean;
} & InfiniteTable_RowInfoBase<T>;
type InfiniteTable_HasGrouping_RowInfoBase<T> = {
    indexInGroup: number;
    /**
     * Available on all rowInfo objects when the datasource is grouped, otherwise, it will be undefined.
     *
     * For group rows, the group keys will have all the keys starting from the topmost parent
     * down to the current group row (including the group row).
     * For normal rows, the group keys will have all the keys starting from the topmost parent
     * down to the last group row in the hierarchy (the direct parent of the current row).
     *
     * Example: People grouped by country and city
     *
     * Italy  - country         - groupKeys: ['Italy']
     *    Rome - city           - groupKeys: ['Italy', 'Rome']
     *      Marco    - person   - groupKeys: ['Italy', 'Rome']
     *      Luca     - person   - groupKeys: ['Italy', 'Rome']
     *      Giuseppe  - person  - groupKeys: ['Italy', 'Rome']
     *
     */
    groupKeys: any[];
    /**
     * Available on all rowInfo objects when the datasource is grouped, otherwise, it will be undefined.
     *
     * Has the same structure as groupKeys, but it will contain the fields used to group the rows.
     *
     * Example: People grouped by country and city
     *
     * Italy  - country         - groupBy: [{field: 'country'}]
     *    Rome - city           - groupBy: [{field: 'country'}, {field: 'city'} ]
     *      Marco    - person   - groupBy: [{field: 'country'}, {field: 'city'} ]
     *      Luca     - person   - groupBy: [{field: 'country'}, {field: 'city'} ]
     *      Giuseppe  - person  - groupBy: [{field: 'country'}, {field: 'city'} ]
     */
    groupBy: GroupBy<T, any>[];
    /**
     * The groupBy value of the DataSource component, mapped to the groupBy.field
     */
    rootGroupBy: GroupBy<T, any>[];
    /**
     * Available on all rowInfo objects when the datasource is grouped.
     *
     * Italy  - country         - parent mapped to their ids will be: [] // rowInfo.parents.map((p: any) => p.id)
     *    Rome - city           - parent mapped to their ids will be: ['Italy']
     *      Marco    - person   - parent mapped to their ids will be: ['Italy','Italy,Rome']
     *      Luca     - person   - parent mapped to their ids will be: ['Italy','Italy,Rome']
     *      Giuseppe  - person  - parent mapped to their ids will be: ['Italy','Italy,Rome']
     * USA - country            - parent mapped to their ids will be: []
     *    LA - city             - parent mapped to their ids will be: ['USA']
     *      Bob  - person       - parent mapped to their ids will be: ['USA','USA,LA']
     */
    parents: InfiniteTable_HasGrouping_RowInfoGroup<T>[];
    /**
     * Available when the datasource is grouped, this will be set for both group and normal rows.
     * 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]
     */
    indexInParentGroups: number[];
    /**
     * Available on all rowInfo objects when the datasource is grouped.
     *
     * For every rowInfo object, it counts the number of leaf/normal rows that the group contains.
     * For normal rows, the groupCount represents the groupCount of the direct parent.
     *
     * Italy  - country         - groupCount: 3
     *    Rome - city           - groupCount: 2
     *      Marco    - person   - groupCount: 2
     *      Luca     - person   - groupCount: 2
     *    Napoli - city         - groupCount: 1
     *      Giuseppe  - person  - groupCount: 1
     * USA - country            - groupCount: 1
     *    LA - city             - groupCount: 1
     *      Bob  - person       - groupCount: 1
     */
    groupCount: number;
    groupNesting: number;
    collapsed: boolean;
    /**
     * This is false only when the DataSource is configured with lazy batching and the current
     * row has not been loaded yet. It has nothing to do with children, only with self.
     */
    selfLoaded: boolean;
};
type GroupKeyType<T extends any = any> = T;
type TreeKeyType<T extends any = any> = T;
type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
type PivotGroupValueType<DataType, KeyType> = {
    reducerResults: PivotReducerResults<KeyType>;
    items: DataType[];
};
type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
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;
};
type DeepMapGroupValueType<DataType, KeyType> = {
    /**
     * These are leaf items. This array may be empty when there is batched lazy loading
     */
    items: DataType[];
    commonData?: Partial<DataType>;
    childrenLoading: boolean;
    childrenAvailable: boolean;
    totalChildrenCount?: number;
    cache: boolean;
    error?: string;
    isTree: false;
    isGroupBy: true;
    reducerResults: Record<string, AggregationReducerResult>;
    pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
};
type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
    column?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<DataType>>> | (({ column, }: {
        column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
    }) => Partial<InfiniteTablePivotColumn<DataType>>);
    columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
        columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnGroup<DataType>>>);
};
type TreeParams<DataType, _KeyType> = {
    isLeafNode: (item: DataType) => boolean;
    getNodeChildren: (item: DataType) => null | DataType[];
    toKey: (item: DataType) => any;
    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
};
type GroupParams<DataType, KeyType> = {
    groupBy: GroupBy<DataType, KeyType>[];
    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
    pivot?: PivotBy<DataType, KeyType>[];
    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
};
type DataGroupResult<DataType, KeyType extends any> = {
    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
    groupParams: GroupParams<DataType, KeyType>;
    initialData: DataType[];
    reducerResults?: Record<string, AggregationReducerResult>;
    topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
    pivot?: PivotBy<DataType, KeyType>[];
};
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[];
type InfiniteTablePropRepeatWrappedGroupRows<T> = boolean | ((rowInfo: InfiniteTableRowInfo<T>) => boolean);

type InfiniteCheckBoxPropChecked = true | false | null;
type InfiniteCheckBoxProps = {
    disabled?: boolean;
    checked?: InfiniteCheckBoxPropChecked;
    defaultChecked?: InfiniteCheckBoxPropChecked;
    onChange?: (checked: InfiniteCheckBoxPropChecked) => void;
    domProps?: React$1.HTMLProps<HTMLElement>;
};
declare function InfiniteCheckBox(props: InfiniteCheckBoxProps): React$1.JSX.Element;

type CoordsWithSize = {
    width: number;
    height: number;
    left: number;
    top: number;
};
type CoordsNoSize = {
    right: number;
    bottom: number;
    left: number;
    top: number;
};
type RectangleCoords = CoordsWithSize | CoordsNoSize;

type Alignable = RectangleCoords | HTMLElement | DOMRect;
type AlignPositionEnum = 'TopLeft' | 'TopCenter' | 'TopRight' | 'CenterRight' | 'BottomRight' | 'BottomCenter' | 'BottomLeft' | 'CenterLeft' | 'Center';
type AlignPositionItem = [AlignPositionEnum, AlignPositionEnum];
type AlignPositionOptions = {
    alignPosition: AlignPositionItem[];
    constrainTo?: Alignable;
    alignAnchor: Alignable;
    alignTarget: Alignable;
};

type OverlayParams = {
    portalContainer?: ElementContainerGetter | null | false;
    constrainTo?: OverlayShowParams['constrainTo'];
};
type ElementContainerGetter = (() => HTMLElement | string | Promise<HTMLElement | string>) | string | HTMLElement | Promise<HTMLElement | string>;
type AdvancedAlignable = Alignable | ElementContainerGetter;
declare function alignNode(node: HTMLDivElement, params: OverlayShowParams): Promise<void>;
/**
 * If portal container is given, it will create a React portal from that element
 * otherwise it will simply render another node as portal
 *
 * @param portalContainer
 */
declare function useOverlayPortal(content: ReactNode, portalContainer?: ElementContainerGetter | null | false): string | number | bigint | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
type OverlayShowParams = {
    id?: string | number;
    constrainTo?: AdvancedAlignable | boolean;
    alignPosition: AlignPositionOptions['alignPosition'];
    alignTo: AdvancedAlignable | PointCoords;
};
type UpdateOverlayContentFn = (content: ReactNode | (() => ReactNode), options?: {
    skipRealign?: boolean;
}) => void;
type ShowOverlayFn = (content: ReactNode | (() => ReactNode), params: OverlayShowParams) => UpdateOverlayContentFn;
declare function useOverlay(params: OverlayParams): {
    portal: string | number | bigint | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
    hideOverlay: (id: string) => void;
    clearAll: () => void;
    rerenderOverlays: () => void;
    showOverlay: ShowOverlayFn;
};

/**

We have this utility - it's used in Menu Renderable declaration
because:

type Renderable = React.ReactNode;

const x: Renderable = <div />;
const y: Renderable = {};

we don't want to allow the above `y` as a valid declaration

it breaks some types in the Menu component as well

 */
type RemoveObject<T> = T extends null | undefined ? T : T extends unknown ? keyof T extends never ? never : T : never;

type MenuSetupState = {
    domRef: MutableRefObject<HTMLDivElement | null>;
    keyboardActiveItemKey: string | null;
    activeItemKey: string | null;
    generatedId: string;
    focused: boolean;
    destroyed: boolean;
};
type MenuDerivedState = {
    runtimeItems: MenuRuntimeItem[];
    runtimeSelectableItems: MenuRuntimeItemSelectable[];
    columns: MenuColumn[];
    menuId: string;
};
type MenuMappedState = {
    parentMenuId: MenuProps['parentMenuId'];
    parentMenuItemKey: MenuProps['parentMenuItemKey'];
    constrainTo: MenuProps['constrainTo'];
    autoFocus: MenuProps['autoFocus'];
    onHideIntent: MenuProps['onHideIntent'];
    onAction: MenuProps['onAction'];
    onShow: MenuProps['onShow'];
    onHide: MenuProps['onHide'];
    wrapLabels: MenuProps['wrapLabels'];
};
interface MenuState extends MenuMappedState, MenuDerivedState, MenuSetupState {
}
type MenuApi = {
    focus: VoidFunction;
    /**
     * hides this and all parent menus
     */
    hideMenu: VoidFunction;
    getMenuId: () => string;
    getParentMenuId: () => string | undefined;
};

type MenuRenderable = string | number | RemoveObject<Renderable>;
type MenuRuntimeItemSelectable = {
    type: 'item';
    key: string;
    parentMenuId: string;
    active: boolean;
    keyboardActive: boolean;
    value: MenuItemObject;
    style?: CSSProperties;
    className?: string;
    disabled: boolean;
    span: number;
    menu: MenuProps | (() => MenuProps) | null;
    originalMenuItem: MenuItemObject;
};
type MenuRuntimeItem = MenuRuntimeItemSelectable | {
    type: 'decoration';
    value: MenuDecoration;
    style: CSSProperties;
    span: number;
};
type MenuChildrenFnParam = {
    item: MenuRuntimeItem;
    column: MenuColumn;
    columns: MenuColumn[];
};
type MenuProps = {
    id?: string;
    portalContainer?: ElementContainerGetter | false | null;
    items?: MenuItemDefinition[];
    constrainTo?: OverlayShowParams['constrainTo'];
    columns?: MenuColumn[];
    children?: MenuRenderable;
    wrapLabels?: boolean;
    onShow?: (state: MenuState, api: MenuApi) => void;
    onHide?: (state: MenuState) => void;
    onHideIntent?: (state: MenuState) => void;
    bubbleActionsFromSubmenus?: boolean;
    addSubmenuColumnIfNeeded?: boolean;
    onAction?: (param: MenuItemActionContext) => void;
    parentMenuId?: string;
    parentMenuItemKey?: string;
    autoFocus?: boolean;
};
type MenuSeparator = '-';
type MenuItemDefinition = MenuItemObject | MenuDecoration | MenuSeparator;
type MenuItemSubMenu = Omit<MenuProps, 'children' | 'items'> & {
    items: (MenuItemObject | MenuSeparator)[];
};
type MenuItemActionContext = {
    hideMenu: () => void;
    key: string;
    item: MenuItemObject;
};
type MenuItemObject = {
    key: string;
    label: NonUndefined<MenuRenderable>;
    span?: number;
    description?: MenuRenderable;
    disabled?: boolean;
    menu?: MenuItemSubMenu | (() => MenuItemSubMenu);
    style?: CSSProperties;
    className?: string;
    onClick?: (event: React.MouseEvent) => void;
    onAction?: (params: MenuItemActionContext) => void;
    hideMenuOnAction?: boolean;
    [k: string]: any;
};
type MenuDecoration = MenuRenderable;
type MenuColumn = {
    flex?: number;
    width?: string | number;
    style?: CSSProperties;
    name: string;
    field?: string;
    render?: (param: MenuColumnRenderParam) => MenuRenderable;
};
type MenuColumnRenderParam = {
    item: MenuItemObject;
    column: MenuColumn;
    value: MenuRenderable;
    domProps: HTMLProps<HTMLDivElement>;
};

type LoadMaskProps = {
    visible: boolean;
    children: Renderable;
};
type InfiniteTablePropColumnOrderNormalized = string[];
type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
type InfiniteTablePropColumnVisibility = Record<string, false>;
type InfiniteTablePropColumnGroupVisibility = Record<string, boolean>;
type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
type InfiniteTablePropColumnPinning = Record<string, true | 'start' | 'end'>;
type InfiniteTableRowStylingFnParams<T> = {
    rowIndex: number;
    rowHasSelectedCells: boolean;
    visibleColumnIds: string[];
    allColumnIds: string[];
} & InfiniteTableRowInfoDataDiscriminator<T>;
type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStylingFnParams<T>) => undefined | React$1.CSSProperties;
type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStylingFnParams<T>) => string | undefined;
type InfiniteTableCellClassNameFn<T> = InfiniteTableColumn<T>['className'];
type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
type InfiniteTablePropCellStyle<T> = InfiniteTableColumn<T>['style'];
type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
type InfiniteTablePropCellClassName<T> = string | InfiniteTableCellClassNameFn<T>;
type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
    getter?: AggregationReducer<T, AggregationResultType>['getter'];
    field?: keyof T;
};
type InfiniteTableColumnType<T> = {
    minWidth?: number;
    maxWidth?: number;
    filterType?: string;
    sortType?: string;
    dataType?: InfiniteTableDataTypeNames;
    defaultWidth?: number;
    defaultFlex?: number;
    defaultPinned?: InfiniteTableColumnPinnedValues;
    defaultHiddenWhenGroupedBy?: InfiniteTableColumn<T>['defaultHiddenWhenGroupedBy'];
    header?: InfiniteTableColumn<T>['header'];
    comparer?: InfiniteTableColumn<T>['comparer'];
    draggable?: InfiniteTableColumn<T>['defaultDraggable'];
    resizable?: InfiniteTableColumn<T>['resizable'];
    align?: InfiniteTableColumn<T>['align'];
    headerAlign?: InfiniteTableColumn<T>['headerAlign'];
    verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
    contentFocusable?: InfiniteTableColumn<T>['contentFocusable'];
    defaultSortable?: InfiniteTableColumn<T>['defaultSortable'];
    defaultEditable?: InfiniteTableColumn<T>['defaultEditable'];
    defaultFilterable?: InfiniteTableColumn<T>['defaultFilterable'];
    columnGroup?: string;
    cssEllipsis?: boolean;
    headerCssEllipsis?: boolean;
    field?: KeyOfNoSymbol<T>;
    components?: InfiniteTableColumn<T>['components'];
    renderMenuIcon?: InfiniteTableColumn<T>['renderMenuIcon'];
    renderSortIcon?: InfiniteTableColumn<T>['renderSortIcon'];
    renderRowDetailIcon?: InfiniteTableColumn<T>['renderRowDetailIcon'];
    renderSelectionCheckBox?: InfiniteTableColumn<T>['renderSelectionCheckBox'];
    renderHeaderSelectionCheckBox?: InfiniteTableColumn<T>['renderHeaderSelectionCheckBox'];
    renderValue?: InfiniteTableColumn<T>['renderValue'];
    render?: InfiniteTableColumn<T>['render'];
    valueGetter?: InfiniteTableColumn<T>['valueGetter'];
    valueFormatter?: InfiniteTableColumn<T>['valueFormatter'];
    getValueToEdit?: InfiniteTableColumn<T>['getValueToEdit'];
    getValueToPersist?: InfiniteTableColumn<T>['getValueToPersist'];
    shouldAcceptEdit?: InfiniteTableColumn<T>['shouldAcceptEdit'];
    style?: InfiniteTableColumn<T>['style'];
    headerStyle?: InfiniteTableColumn<T>['headerStyle'];
    headerClassName?: InfiniteTableColumn<T>['headerClassName'];
};
type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
type InfiniteTableColumnSizingOptions = {
    flex?: number;
    width?: number;
    minWidth?: number;
    maxWidth?: number;
};
type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
type ColumnCellValues = {
    value: any;
    rawValue: any;
    formattedValue: any;
};
type InfiniteTableColumnApi<_T> = {
    showContextMenu: (target: EventTarget | HTMLElement) => void;
    toggleContextMenu: (target: EventTarget | HTMLElement) => void;
    hideContextMenu: () => void;
    showFilterOperatorMenu: (target: EventTarget | HTMLElement) => void;
    toggleFilterOperatorMenu: (target: EventTarget | HTMLElement) => void;
    hideFilterOperatorMenu: () => void;
    isVisible: () => boolean;
    isSortable: () => boolean;
    getSortInfo: () => DataSourceSingleSortInfo<_T> | null;
    getSortDir(): SortDir | null;
    toggleSort: (options?: MultiSortBehaviorOptions) => void;
    clearSort: () => void;
    setSort: (sort: SortDir | null, options?: MultiSortBehaviorOptions) => void;
    setFilter: (value: any) => void;
    clearFilter: (value: any) => void;
    getCellValuesByPrimaryKey: (id: any) => null | ColumnCellValues;
    getCellValueByPrimaryKey: (id: any) => any | null;
};
type InfiniteTableApiStartEditParams = InfiniteTableApiIsCellEditableParams & {
    value?: any;
};
type InfiniteTableApiStopEditParams = {
    cancel: true;
    reject?: never;
    value?: never;
} | {
    reject: Error;
    cancel?: never;
    value?: never;
} | {
    value?: any;
    cancel?: never;
    reject?: never;
};
type InfiniteTableApiIsCellEditableParams = InfiniteTableApiCellLocator;
type InfiniteTableApiCellLocator = {
    columnId: string;
} & XOR<{
    rowIndex: number;
}, {
    primaryKey: any;
}>;
type InfiniteTableApiStopEditPromiseResolveType = {
    cancel: true;
    value: null;
} | {
    reject: Error;
    value: any;
} | boolean;
type MultiSortBehaviorOptions = {
    multiSortBehavior?: InfiniteTablePropMultiSortBehavior;
};
interface InfiniteTableApi<T> {
    get rowDetailApi(): InfiniteTableRowDetailApi;
    get rowSelectionApi(): InfiniteTableRowSelectionApi;
    get cellSelectionApi(): InfiniteTableCellSelectionApi<T>;
    get keyboardNavigationApi(): InfiniteTableKeyboardNavigationApi<T>;
    get scrollContainer(): HTMLElement;
    setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
    setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
    isDestroyed: () => boolean;
    clearEditInfo: () => void;
    hideContextMenu: () => void;
    hideFilterOperatorMenu: () => void;
    realignColumnContextMenu: () => void;
    getColumnOrder: () => string[];
    getVisibleColumnOrder: () => string[];
    getComputedColumnById: (colId: string) => InfiniteTableComputedColumn<T> | undefined;
    isEditorVisibleForCell(params: {
        rowIndex: number;
        columnId: string;
    }): boolean;
    get scrollLeftMax(): number;
    get scrollLeft(): number;
    set scrollLeft(value: number);
    get scrollTopMax(): number;
    get scrollTop(): number;
    set scrollTop(value: number);
    isCellEditable: (params: InfiniteTableApiIsCellEditableParams) => Promise<boolean>;
    getColumnAtIndex: (index: number) => InfiniteTableComputedColumn<T> | null;
    startEdit: (params: InfiniteTableApiStartEditParams) => Promise<boolean>;
    stopEdit: (params?: InfiniteTableApiStopEditParams) => Promise<InfiniteTableApiStopEditPromiseResolveType>;
    persistEdit: (params?: {
        value?: any;
    }) => Promise<true | Error>;
    rejectEdit: (error: Error) => Promise<InfiniteTableApiStopEditPromiseResolveType>;
    confirmEdit: (value?: any) => Promise<InfiniteTableApiStopEditPromiseResolveType>;
    cancelEdit: () => Promise<InfiniteTableApiStopEditPromiseResolveType>;
    isEditInProgress: () => boolean;
    getVerticalRenderRange: () => {
        renderStartIndex: number;
        renderEndIndex: number;
    };
    collapseAllGroupRows: () => void;
    toggleGroupRow: (groupKeys: any[]) => void;
    collapseGroupRow: (groupKeys: any[]) => boolean;
    expandGroupRow: (groupKeys: any[]) => boolean;
    setSortInfoForColumn: (columnId: string, sortInfo: DataSourceSingleSortInfo<T> | null) => void;
    getSortInfoForColumn: (columnId: string) => DataSourceSingleSortInfo<T> | null;
    getSortTypeForColumn: (columnId: string) => string | string[] | null;
    toggleSortingForColumn: (columnId: string, options?: MultiSortBehaviorOptions) => void;
    setColumnFilter: (columnId: string, filterValue: any) => void;
    setColumnFilterOperator: (columnId: string, operator: string) => void;
    /**
     * Clears the filter for the given column to a default value. The column will still have a
     * corresponding filterValue, though set to the empty filter value, so it's not considered filtered.
     */
    clearColumnFilter: (columnId: string) => void;
    /**
     * Removes the filter for the column altogether. The column will no longer have a corresponding entry in the filterValue prop.
     */
    removeColumnFilter: (columnId: string) => void;
    isColumnSortable: (columnId: string) => boolean;
    setFilterValueForColumn: (columnId: string, filterValue: DataSourceFilterValueItem<T>) => void;
    setPinningForColumn: (columnId: string, pinning: InfiniteTableColumnPinnedValues) => void;
    setSortingForColumn: (columnId: string, dir: SortDir | null) => void;
    getSortingForColumn: (columnId: string) => SortDir | null;
    getColumnApi: (columnId: string) => InfiniteTableColumnApi<T> | null;
    setVisibilityForColumn: (columnId: string, visible: boolean) => void;
    setVisibilityForColumnGroup: (columnGroupId: string, visible: boolean) => void;
    getVisibleColumnsCount: () => number;
    scrollRowIntoView: (rowIndex: number, config?: {
        scrollAdjustPosition?: ScrollAdjustPosition;
        offset?: number;
    }) => boolean;
    scrollColumnIntoView: (colId: string, config?: {
        scrollAdjustPosition?: ScrollAdjustPosition;
        offset?: number;
    }) => boolean;
    scrollCellIntoView: (rowIndex: number, colIdOrIndex: string | number, config?: {
        scrollAdjustPosition?: ScrollAdjustPosition;
        offset?: number;
    }) => boolean;
    getCellValues: (cellLocator: InfiniteTableApiCellLocator) => ColumnCellValues | null;
    getCellValue: (cellLocator: InfiniteTableApiCellLocator) => any | null;
    getState: () => InfiniteTableState<T>;
    getDataSourceState: () => DataSourceState<T>;
    focus: () => void;
    setGroupRenderStrategy: (groupRenderStrategy: InfiniteTablePropGroupRenderStrategy) => void;
}
type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = Record<string, ColumnType>;
type InfiniteTablePropColumnGroups = Record<string, InfiniteTableColumnGroup>;
type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
type InfiniteTableColumnGroupHeaderRenderParams = {
    columnGroup: InfiniteTableComputedColumnGroup;
    horizontalLayoutPageIndex: number | null;
};
type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
type InfiniteTableColumnGroupStyleFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => React$1.CSSProperties;
type InfiniteTableColumnGroup = {
    columnGroup?: string;
    header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
    style?: React$1.CSSProperties | InfiniteTableColumnGroupStyleFunction;
};
type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
    id: string;
    groupOffset: number;
    computedWidth: number;
    uniqueGroupId: string[];
    columns: string[];
    depth: number;
};
type InfiniteTableGroupColumnGetterOptions<T> = {
    groupIndexForColumn?: number;
    groupByForColumn?: DataSourceGroupBy<T>;
    selectionMode: DataSourcePropSelectionMode;
    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
    groupCount: number;
    groupBy: DataSourceGroupBy<T>[];
    pivotBy?: DataSourcePivotBy<T>[];
    sortable?: boolean;
};
type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
    column: COL_TYPE;
    groupBy: DataSourcePropGroupBy<T>;
    pivotBy: DataSourcePropPivotBy<T>;
};
type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<T>;
    id?: string;
};
type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
    renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
};
type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
type RowDetailComponentProps<T = any> = {
    rowInfo: InfiniteTableRowInfo<T>;
    cache: RowDetailCacheStorageForCurrentRow<RowDetailCacheEntry>;
};
type InfiniteTablePropComponents<T = any> = {
    LoadMask?: (props: LoadMaskProps & {
        children?: React$1.ReactNode | undefined;
    }) => React$1.JSX.Element | null;
    CheckBox?: (props: InfiniteCheckBoxProps) => React$1.JSX.Element | null;
    Menu?: (props: MenuProps & {
        children?: React$1.ReactNode | undefined;
    }) => React$1.JSX.Element | null;
    MenuIcon?: (props: MenuIconProps) => React$1.JSX.Element | null;
    RowDetail?: (props: RowDetailComponentProps<T>) => React$1.JSX.Element | null;
};
type ScrollStopInfo = {
    scrollTop: number;
    scrollLeft: number;
    viewportSize: Size;
    renderRange: TableRenderRange;
    firstVisibleRowIndex: number;
    lastVisibleRowIndex: number;
    firstVisibleColIndex: number;
    lastVisibleColIndex: number;
};
type InfiniteTableRowInfoDataDiscriminatorWithColumn<T> = {
    column: InfiniteTableComputedColumn<T>;
    columnApi: InfiniteTableColumnApi<T>;
} & InfiniteTableRowInfoDataDiscriminator<T>;
type InfiniteTableRowInfoDataDiscriminatorWithColumnAndApis<T> = {
    api: InfiniteTableApi<T>;
    dataSourceApi: DataSourceApi<T>;
} & InfiniteTableRowInfoDataDiscriminatorWithColumn<T>;
type InfiniteTablePropEditable<T> = InfiniteTableColumnEditableFn<T> | undefined;
type InfiniteTablePropSortable<T> = InfiniteTableColumnSortable<T> | undefined;
type InfiniteTablePropOnEditAcceptedParams<T> = InfiniteTableRowInfoDataDiscriminatorWithColumnAndApis<T> & {
    initialValue: any;
};
type InfiniteTablePropOnEditCancelledParams<T> = InfiniteTablePropOnEditAcceptedParams<T>;
type InfiniteTablePropOnEditRejectedParams<T> = InfiniteTableRowInfoDataDiscriminatorWithColumnAndApis<T> & {
    initialValue: any;
    error: Error;
};
type InfiniteTablePropOnEditPersistParams<T> = InfiniteTablePropOnEditAcceptedParams<T>;
type InfiniteTablePropMultiSortBehavior = 'append' | 'replace';
type InfiniteTablePropKeyboardShorcut = {
    key: string | string[];
    when?: (context: InfiniteTableKeyboardEventHandlerContext<any>) => boolean | Promise<boolean>;
    handler: (context: InfiniteTableKeyboardEventHandlerContext<any>, event: KeyboardEvent) => void | {
        stopNext: boolean;
    } | Promise<any>;
};
type InfiniteTablePropOnCellDoubleClickResult = Partial<{
    preventEdit: boolean;
}>;
type InfiniteTablePropOnKeyDownResult = Partial<{
    preventEdit: boolean;
    preventEditStop: boolean;
    preventDefaultForTabKeyWhenEditing: boolean;
    preventSelection: boolean;
    preventNavigation: boolean;
}>;
interface InfiniteTableProps<T> {
    debugId?: string;
    columns: InfiniteTablePropColumns<T>;
    pivotColumns?: InfiniteTablePropColumns<T, InfiniteTablePivotColumn<T>>;
    children?: React$1.JSX.Element | React$1.JSX.Element[] | React$1.ReactNode;
    loadingText?: Renderable;
    components?: InfiniteTablePropComponents<T>;
    wrapRowsHorizontally?: boolean;
    keyboardShortcuts?: InfiniteTablePropKeyboardShorcut[];
    repeatWrappedGroupRows?: InfiniteTablePropRepeatWrappedGroupRows<T>;
    viewportReservedWidth?: number;
    onViewportReservedWidthChange?: (viewportReservedWidth: number) => void;
    showColumnFilters?: boolean;
    pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
    columnDefaultFilterable?: boolean;
    columnDefaultEditable?: boolean;
    /**
     * Default behavior for column sorting. Defaults to true.
     *
     * This is overriden by all other props that can control sorting behavior (`column.defaultSortable`, `columnType.defaultSortable`, `sortable`).
     */
    columnDefaultSortable?: boolean;
    /**
     * This overrides both the global `columnDefaultSortable` prop and the column's own `defaultSortable` prop.
     * When used, it's the ultimate source of truth for whether (and which) columns are sortable.
     */
    sortable?: InfiniteTablePropSortable<T>;
    /**
     * This overrides both the global `columnDefaultEditable` prop and the column's own `defaultEditable` prop.
     */
    editable?: InfiniteTablePropEditable<T>;
    pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
    pivotGrandTotalColumnPosition?: InfiniteTablePropPivotGrandTotalColumnPosition;
    groupColumn?: InfiniteTablePropGroupColumn<T>;
    groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
    hideEmptyGroupColumns?: boolean;
    columnVisibility?: InfiniteTablePropColumnVisibility;
    columnGroupVisibility?: InfiniteTablePropColumnGroupVisibility;
    defaultColumnGroupVisibility?: InfiniteTablePropColumnGroupVisibility;
    defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
    pinnedStartMaxWidth?: number;
    pinnedEndMaxWidth?: number;
    shouldAcceptEdit?: InfiniteTableColumn<T>['shouldAcceptEdit'];
    onEditCancelled?: (params: InfiniteTablePropOnEditCancelledParams<T>) => void;
    onEditAccepted?: (params: InfiniteTablePropOnEditAcceptedParams<T>) => void;
    onEditRejected?: (params: InfiniteTablePropOnEditRejectedParams<T>) => void;
    persistEdit?: (params: InfiniteTablePropOnEditPersistParams<T>) => any | Error | Promise<any | Error>;
    onEditPersistSuccess?: (params: InfiniteTablePropOnEditPersistParams<T>) => void;
    onEditPersistError?: (params: InfiniteTablePropOnEditPersistParams<T> & {
        error: Error;
    }) => void;
    columnPinning?: InfiniteTablePropColumnPinning;
    defaultColumnPinning?: InfiniteTablePropColumnPinning;
    onColumnPinningChange?: (columnPinning: InfiniteTablePropColumnPinning) => void;
    columnSizing?: InfiniteTablePropColumnSizing;
    defaultColumnSizing?: InfiniteTablePropColumnSizing;
    onColumnSizingChange?: (columnSizing: InfiniteTablePropColumnSizing) => void;
    pivotColumnGroups?: InfiniteTablePropColumnGroups;
    columnGroups?: InfiniteTablePropColumnGroups;
    defaultColumnGroups?: InfiniteTablePropColumnGroups;
    defaultCollapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
    collapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
    onScrollbarsChange?: (scrollbars: Scrollbars) => void;
    onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
    onColumnGroupVisibilityChange?: (columnGroupVisibility: InfiniteTablePropColumnGroupVisibility) => void;
    columnTypes?: InfiniteTablePropColumnTypes<T>;
    showSeparatePivotColumnForSingleAggregation?: boolean;
    isRowDetailExpanded?: (rowInfo: InfiniteTableRowInfo<T>) => boolean;
    isRowDetailEnabled?: (rowInfo: InfiniteTableRowInfo<T>) => boolean;
    rowDetailCache?: boolean | number;
    rowDetailState?: RowDetailState | RowDetailStateObject<any>;
    defaultRowDetailState?: RowDetailState | RowDetailStateObject<any>;
    onRowDetailStateChange?: (rowDetailState: RowDetailState, { expandRow, collapseRow, }: {
        expandRow: any | null;
        collapseRow: any | null;
    }) => void;
    rowHeight?: number | string | ((rowInfo: InfiniteTableRowInfo<T>) => number);
    rowDetailHeight?: number | string | ((rowInfo: InfiniteTableRowInfo<T>) => number);
    rowDetailRenderer?: (rowInfo: InfiniteTableRowInfo<T>, cache: RowDetailCacheStorageForCurrentRow<RowDetailCacheEntry>) => Renderable;
    rowStyle?: InfiniteTablePropRowStyle<T>;
    cellStyle?: InfiniteTablePropCellStyle<T>;
    cellClassName?: InfiniteTablePropCellClassName<T>;
    rowClassName?: InfiniteTablePropRowClassName<T>;
    columnHeaderHeight?: number | string;
    onKeyDown?: (context: InfiniteTablePublicContext<T> & {
        actions: InfiniteTableEventHandlerContext<T>['actions'];
    }, event: React$1.KeyboardEvent) => void | InfiniteTablePropOnKeyDownResult;
    onCellClick?: (context: InfiniteTablePublicContext<T> & InfiniteTableCellContext<T>, event: React$1.MouseEvent) => void;
    onCellDoubleClick?: (context: InfiniteTablePublicContext<T> & InfiniteTableCellContext<T>, event: React$1.MouseEvent) => void | InfiniteTablePropOnCellDoubleClickResult;
    onContextMenu?: (context: InfiniteTablePublicContext<T> & {
        event: React$1.MouseEvent;
    } & Partial<InfiniteTableRowInfoDataDiscriminatorWithColumn<T>>, event: React$1.MouseEvent) => void;
    onCellContextMenu?: (context: InfiniteTablePublicContext<T> & InfiniteTableRowInfoDataDiscriminatorWithColumn<T> & {
        event: React$1.MouseEvent;
    }, event: React$1.MouseEvent) => void;
    /**
     * Properties to be sent directly to the DOM element underlying InfiniteTable.
     *
     * Useful for passing a className or style and any other event handlers. For more context
     * on some event handlers (eg: onKeyDown), you might want to use dedicated props that give you access
     * to component state as well.
     */
    domProps?: React$1.HTMLAttributes<HTMLDivElement>;
    /**
     * A unique identifier for the table instance. Will not be passed to the DOM.
     */
    id?: string;
    showZebraRows?: boolean;
    showHoverRows?: boolean;
    multiSortBehavior?: InfiniteTablePropMultiSortBehavior;
    keyboardNavigation?: InfiniteTablePropKeyboardNavigation;
    keyboardSelection?: InfiniteTablePropKeyboardSelection;
    defaultActiveRowIndex?: number | null;
    activeRowIndex?: number | null;
    onActiveRowIndexChange?: (activeRowIndex: number) => void;
    onActiveCellIndexChange?: (activeCellIndex: [number, number]) => void;
    activeCellIndex?: [number, number] | null;
    defaultActiveCellIndex?: [number, number] | null;
    /**
     * Whether the columns are draggable by default.
     *
     * This is the prop that has the lowest priority - it's overridden by column.defaultDraggable and ultimately by draggableColumns
     */
    columnDefaultDraggable?: boolean;
    /**
     * Whether the columns are draggable by default.
     *
     * This is the prop that has the highest priority - overrides columnDefaultDraggable and column.defaultDraggable
     */
    draggableColumns?: boolean;
    draggableColumnsRestrictTo?: false | 'group';
    header?: boolean;
    headerOptions?: InfiniteTablePropHeaderOptions;
    focusedClassName?: string;
    focusedWithinClassName?: string;
    focusedStyle?: React$1.CSSProperties;
    focusedWithinStyle?: React$1.CSSProperties;
    columnCssEllipsis?: boolean;
    columnHeaderCssEllipsis?: boolean;
    columnDefaultWidth?: number;
    columnDefaultFlex?: number;
    columnMinWidth?: number;
    columnMaxWidth?: number;
    hideColumnWhenGrouped?: boolean;
    resizableColumns?: boolean;
    virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
    virtualizeRows?: boolean;
    onSelfFocus?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
    onSelfBlur?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
    onFocusWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
    onBlurWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
    /**
     * When a column is hidden by using the column menu, the column menu will stay open,
     * so it needs (generally) to be realigned to the correct location. This prop
     * configures the delay in milliseconds before the column menu is realigned.
     *
     * @default 50
     */
    columnMenuRealignDelay?: number;
    onScrollToTop?: () => void;
    onScrollToBottom?: () => void;
    scrollStopDelay?: number;
    onScrollStop?: (param: ScrollStopInfo) => void;
    scrollToBottomOffset?: number;
    onRenderRangeChange?: (range: TableRenderRange) => void;
    defaultColumnOrder?: InfiniteTablePropColumnOrder;
    columnOrder?: InfiniteTablePropColumnOrder;
    onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrderNormalized) => void;
    onRowHeightChange?: (rowHeight: number) => void;
    onRowMouseEnter?: (context: InfiniteTableRowContext<T>, event: React$1.MouseEvent) => void;
    onRowMouseLeave?: (context: InfiniteTableRowContext<T>, event: React$1.MouseEvent) => void;
    onReady?: ({ api, dataSourceApi, }: {
        api: InfiniteTableApi<T>;
        dataSourceApi: DataSourceApi<T>;
    }) => void;
    rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStylingFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
    licenseKey?: string;
    scrollTopKey?: string | number;
    autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
    getCellContextMenuItems?: InfiniteTablePropGetCellContextMenuItems<T>;
    getContextMenuItems?: InfiniteTablePropGetContextMenuItems<T>;
    getColumnMenuItems?: InfiniteTablePropGetColumnMenuItems<T>;
    getFilterOperatorMenuItems?: InfiniteTablePropGetFilterOperatorMenuItems<T>;
}
type InfiniteTablePropGetColumnMenuItems<T> = (defaultItems: Exclude<MenuProps['items'], undefined>, params: {
    column: InfiniteTableComputedColumn<T>;
    columnApi: InfiniteTableColumnApi<T>;
    getComputed: () => InfiniteTableComputedValues<T>;
} & InfiniteTablePublicContext<T>) => MenuProps['items'];
type GetContextMenuItemsReturnType = MenuProps['items'] | null | {
    items: MenuProps['items'];
    columns: MenuColumn[];
};
type InfiniteTablePropGetCellContextMenuItems<T> = (info: InfiniteTableRowInfoDataDiscriminatorWithColumn<T> & {
    event: React$1.MouseEvent;
}, params: InfiniteTablePublicContext<T>) => Promise<GetContextMenuItemsReturnType> | GetContextMenuItemsReturnType;
type InfiniteTablePropGetContextMenuItems<T> = (param: {
    event: React$1.MouseEvent;
} & Partial<InfiniteTableRowInfoDataDiscriminatorWithColumn<T>>, params: InfiniteTablePublicContext<T>) => Promise<GetContextMenuItemsReturnType> | GetContextMenuItemsReturnType;
type InfiniteTablePropGetFilterOperatorMenuItems<T> = (defaultItems: Exclude<MenuProps['items'], undefined>, params: {
    column: InfiniteTableComputedColumn<T>;
    filterTypes: DataSourceProps<T>['filterTypes'];
    columnFilterValue: DataSourceFilterValueItem<T> | null;
    api: InfiniteTableApi<T>;
    getState: () => InfiniteTableState<T>;
    getComputed: () => InfiniteTableComputedValues<T>;
    actions: InfiniteTableActions<T>;
}) => MenuProps['items'];
type InfiniteTablePropKeyboardNavigation = 'cell' | 'row' | false;
type InfiniteTablePropKeyboardSelection = boolean;
type InfiniteTablePropHeaderOptions = {
    alwaysReserveSpaceForSortIcon: boolean;
};
type InfiniteTablePropAutoSizeColumnsKey = string | number | {
    key: string | number;
    columnsToSkip?: string[];
    columnsToResize?: string[];
    includeHeader?: boolean;
};
type Scrollbars = {
    vertical: boolean;
    horizontal: boolean;
};
type ScrollAdjustPosition = 'start' | 'end' | 'center';
type InfiniteColumnEditorContextType<T> = {
    api: InfiniteTableApi<T>;
    initialValue: any;
    value: any;
    readOnly: boolean;
    column: InfiniteTableComputedColumn<T>;
    rowInfo: InfiniteTableRowInfo<T>;
    setValue: (value: any) => void;
    confirmEdit: InfiniteTableApi<T>['confirmEdit'];
    cancelEdit: InfiniteTableApi<T>['cancelEdit'];
    rejectEdit: InfiniteTableApi<T>['rejectEdit'];
};

declare function debounce(fn: Function, { wait }: {
    wait: number;
}): (...args: any[]) => void;

type DataSourceChildren<T> = React$1.ReactNode | ((values: DataSourceState<T>) => React$1.ReactNode);

declare function useDataSourceInternal<T, PROPS_TYPE = DataSourceProps<T>>(props: Omit<PROPS_TYPE, 'children'>): {
    DataSource: ({ children }: {
        children: DataSourceChildren<T>;
        nodesKey?: string;
    }) => React__default.JSX.Element;
    state: DataSourceState<T>;
};

type DataQuerySnapshot = {
    state: 'idle' | 'loading' | 'success' | 'error';
    result: any;
    error: any;
    done: boolean;
    doneAt: number;
    promise?: Promise<DataQuery>;
};
declare class DataQuery {
    private state;
    private result;
    private error;
    private doneAt;
    private pendingPromise;
    debugName: string;
    private logger;
    constructor(debugName: string);
    fetch: (loadFn: DataQueryFn, ...key: DataQueryKey[]) => Promise<DataQuerySnapshot>;
    getCurrentSnapshot: () => DataQuerySnapshot;
    getDoneSnapshot: () => Promise<DataQuerySnapshot>;
    getResult: () => any;
    isDone: () => boolean;
    isSuccess: () => boolean;
}
type DataQueryKey = string | number | boolean | null | symbol | {
    [key: string]: DataQueryKey | undefined;
} | Array<DataQueryKey>;
type DataQueryFn = (...key: DataQueryKey[]) => Promise<any>;

type QueryOptions = {
    fn: DataQueryFn;
    key: DataQueryKey[];
    name?: string;
};
declare function queryKeyToCacheKey(key: DataQueryKey): any;
declare class DataClient {
    private options;
    private queryCache;
    static clients: Map<string, DataClient>;
    private name;
    static destroy(clientName: string): void;
    static destroyAll(): void;
    constructor(options: DataClientOptions);
    private removeQueryIfErrored;
    private fireQuery;
    query: (options: QueryOptions) => DataQuerySnapshot;
    awaitQuery: (options: QueryOptions) => Promise<DataQuerySnapshot>;
    isQueryInProgress: (key: DataQueryKey[]) => boolean;
    hasQueryForKey: (key: DataQueryKey[]) => boolean;
    discardQueryForKey: (key: DataQueryKey[]) => void;
    destroy(): void;
}
type DataClientOptions = {
    name: string;
    cache?: boolean;
};

declare function Menu(props: MenuProps & HTMLProps<HTMLDivElement>): React$1.JSX.Element;
declare namespace Menu {
    var __is_infinite_menu_component: boolean;
}

declare function useEffectWithChanges<T>(fn: (changes: Record<keyof T, any>, prevValues: Record<string, any>) => void | (() => void), deps: Record<keyof T, any>): void;
declare function useLayoutEffectWithChanges<T>(fn: (changes: Record<keyof T, any>, prevValues: Record<string, any>) => void | (() => void), deps: Record<keyof T, any>): void;
declare function useEffectWithObject(fn: EffectCallback, deps: Record<string, any>): void;

declare function StringFilterEditor<T>(): React$1.JSX.Element;
declare function NumberFilterEditor<T>(): React$1.JSX.Element;

declare const keyboardShortcuts: {
    instantEdit: InfiniteTablePropKeyboardShorcut;
};

type InterceptedMapFns<K, V> = {
    set?: (k: K, v: V) => void;
    beforeClear?: (map: Map<K, V>) => void;
    clear?: () => void;
    delete?: (k: K) => void;
};
/**
 *
 * @param map Map to intercept
 * @param fns fns to inject
 * @returns a function to restore the map to initial methods
 */
declare function interceptMap<K, V>(map: Map<K, V>, fns: InterceptedMapFns<K, V>): () => void;

declare class FixedSizeSet<T> {
    private currentSet;
    private maxSize;
    private orderRefs;
    static DEFAULT_SIZE: number;
    constructor(clone?: readonly T[] | null | number, size?: number);
    values(): SetIterator<T>;
    get size(): number;
    delete(el: T): boolean;
    has(el: T): boolean;
    add(el: T): this;
}

declare class WeakFixedSizeSet<T extends object> {
    private currentSet;
    private maxSize;
    private orderRefs;
    static DEFAULT_SIZE: number;
    constructor(clone?: readonly T[] | null | number, size?: number);
    values(): SetIterator<T>;
    get size(): number;
    delete(el: T): boolean;
    has(el: T): boolean;
    add(el: T): this;
}

declare const useEffectWhenSameDeps: (callback: EffectCallback, deps: DependencyList) => void;

declare const useEffectWhen: (callback: EffectCallback, options: {
    same: DependencyList;
    different: DependencyList;
    compare?: (a: any, b: any) => boolean;
}) => void;

declare const usePrevious: <T>(value: T, initialValue?: T) => T;

type FlashingCellOptions = {
    flashDuration?: number;
    flashClassName?: string;
    render?: (props: {
        children: React$1.ReactNode;
        oldValue: any;
    }) => React$1.ReactNode;
};
declare const createFlashingColumnCellComponent: (options?: FlashingCellOptions) => React$1.ForwardRefExoticComponent<Omit<React$1.HTMLProps<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const FlashingColumnCell: React$1.ForwardRefExoticComponent<Omit<React$1.HTMLProps<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const components: {
    CheckBox: typeof InfiniteCheckBox;
    LoadMask: (props: LoadMaskProps) => React$1.JSX.Element;
    MenuIcon: typeof MenuIcon;
    StringFilterEditor: typeof StringFilterEditor;
    NumberFilterEditor: typeof NumberFilterEditor;
};

export { type AdvancedAlignable, CellSelectionState, type CellSelectionStateObject, type ColumnTypeWithInherit, DataClient, DataSource, type DataSourceAction, DataSourceActionType, type DataSourceAggregationReducer, type DataSourceApi, type DataSourceCRUDParam, type DataSourceCallback_BaseParam, type DataSourceComponentActions, type DataSourceContextValue, type DataSourceData, type DataSourceDataParams, type DataSourceDataParamsChanges, type DataSourceDebugWarningKey, type DataSourceDerivedState, type DataSourceFilterFunctionParam, type DataSourceFilterOperator, type DataSourceFilterOperatorFunction, type DataSourceFilterOperatorFunctionParam, type DataSourceFilterType, type DataSourceFilterValueItem, type DataSourceFilterValueItemValueGetter, type DataSourceGroupBy, type DataSourceGroupRowsList, type DataSourceInsertParam, type DataSourceLivePaginationCursorFn, type DataSourceLivePaginationCursorParams, type DataSourceLivePaginationCursorValue, type DataSourceMappedState, type DataSourceMappings, type DataSourceMasterDetailContextValue, type DataSourcePivotBy, type DataSourcePropAggregationReducers, type DataSourcePropCellSelection, type DataSourcePropCellSelection_MultiCell, type DataSourcePropCellSelection_SingleCell, type DataSourcePropFilterFunction, type DataSourcePropFilterTypes, type DataSourcePropFilterValue, type DataSourcePropGroupBy, type DataSourcePropGroupRowsStateObject, type DataSourcePropIsNodeExpanded, type DataSourcePropIsNodeReadOnly, type DataSourcePropIsNodeSelectable, type DataSourcePropIsNodeSelected, type DataSourcePropIsRowSelected, type DataSourcePropLivePaginationCursor, type DataSourcePropMultiRowSelectionChangeParamType, type DataSourcePropOnCellSelectionChange, type DataSourcePropOnCellSelectionChange_MultiCell, type DataSourcePropOnCellSelectionChange_SingleCell, type DataSourcePropOnRowSelectionChange, type DataSourcePropOnRowSelectionChange_MultiRow, type DataSourcePropOnRowSelectionChange_SingleRow, type DataSourcePropOnTreeSelectionChange, type DataSourcePropOnTreeSelectionChange_MultiNode, type DataSourcePropOnTreeSelectionChange_SingleNode, type DataSourcePropPivotBy, type DataSourcePropRowInfoReducers, type DataSourcePropRowSelection, type DataSourcePropRowSelection_MultiRow, type DataSourcePropRowSelection_SingleRow, type DataSourcePropSelectionMode, type DataSourcePropShouldReloadData, type DataSourcePropShouldReloadDataObject, type DataSourcePropSortFn, type DataSourcePropSortInfo, type DataSourcePropSortTypes, type DataSourcePropTreeFilterFunction, type DataSourcePropTreeSelection, type DataSourcePropTreeSelection_MultiNode, type DataSourcePropTreeSelection_SingleNode, type DataSourceProps, type DataSourcePropsNotAvailableInTreeDataSource, type DataSourcePropsWithChildren, type DataSourceRawReducer, type DataSourceRemoteData, type DataSourceRowInfoReducer, type DataSourceSetupState, type DataSourceSingleSortInfo, type DataSourceSortInfo, type DataSourceState, type DataSourceUpdateParam, type DebugLogger, type DebugTimingKey, type DebugWarningPayload, DeepMap, type DevToolsDataSourceOverrides, type DevToolsGenericMessage, type DevToolsHookFn, type DevToolsHookFnOptions, type DevToolsHostPageLogMessage, type DevToolsHostPageLogMessagePayload, type DevToolsHostPageMessage, type DevToolsHostPageMessagePayload, type DevToolsHostPageMessageType, type DevToolsInfiniteOverrides, type DevToolsMessageAddress, type DevToolsOverrides, type ElementContainerGetter, type ErrorCodeKey, FixedSizeSet, FlashingColumnCell, GroupRowsState, type InfiniteColumnEditorContextType, InfiniteTable, type InfiniteTableAction, InfiniteTableActionType, type InfiniteTableApi, type InfiniteTableCellSelectionApi, InfiniteTableClassName, type InfiniteTableColumn, type InfiniteTableColumnAggregator, type InfiniteTableColumnApi, type InfiniteTableColumnCellContextType, type InfiniteTableColumnComparer, type InfiniteTableColumnGroup, type InfiniteTableColumnRenderFunctionForGroupRows, type InfiniteTableColumnRenderFunctionForNormalRows, type InfiniteTableColumnRenderValueParam, type InfiniteTableColumnRowspanParam, type InfiniteTableColumnSizingOptions, type InfiniteTableColumnValueFormatterParams, type InfiniteTableColumnValueGetterParams, InfiniteTableComponent, type InfiniteTableComputedColumn, type InfiniteTableComputedValues, type InfiniteTableContextValue, type InfiniteTableDebugWarningKey, type InfiniteTableGroupColumnBase, type InfiniteTableGroupColumnFunction, type InfiniteTableGroupColumnGetterOptions, type InfiniteTableKeyboardNavigationApi, type InfiniteTablePivotColumn, type InfiniteTablePropAutoSizeColumnsKey, type InfiniteTablePropColumnGroupVisibility, type InfiniteTablePropColumnGroups, type InfiniteTablePropColumnOrder, type InfiniteTablePropColumnPinning, type InfiniteTablePropColumnSizing, type InfiniteTablePropColumnTypes, type InfiniteTablePropColumnVisibility, type InfiniteTablePropColumns, type InfiniteTablePropComponents, type InfiniteTablePropGetCellContextMenuItems, type InfiniteTablePropGetColumnMenuItems, type InfiniteTablePropGetContextMenuItems, type InfiniteTablePropGroupColumn, type InfiniteTablePropGroupRenderStrategy, type InfiniteTablePropHeaderOptions, type InfiniteTablePropKeyboardNavigation, type InfiniteTablePropKeyboardShorcut, type InfiniteTablePropMultiSortBehavior, type InfiniteTablePropRowClassName, type InfiniteTablePropRowStyle, type InfiniteTableProps, type InfiniteTablePropsNotAvailableInTreeGrid, type InfiniteTableRowClassNameFn, type InfiniteTableRowDetailApi, type InfiniteTableRowInfo, type InfiniteTableRowSelectionApi, type InfiniteTableRowStyleFn, type InfiniteTableState, type InfiniteTable_HasGrouping_RowInfoGroup, type InfiniteTable_HasGrouping_RowInfoNormal, type InfiniteTable_Tree_RowInfoLeafNode, type InfiniteTable_Tree_RowInfoNode, type InfiniteTable_Tree_RowInfoParentNode, type LazyGroupDataDeepMap, type LazyGroupDataItem, type LazyRowInfoGroup, Menu, type MenuChildrenFnParam, type MenuColumn, type MenuColumnRenderParam, type MenuDecoration, type MenuIconProps, type MenuItemActionContext, type MenuItemDefinition, type MenuItemObject, type MenuProps, type MenuRenderable, type MenuRuntimeItem, type MenuRuntimeItemSelectable, type MenuSeparator, type OverlayShowParams, RowDetailCache, RowDetailState, type RowDetailStateObject, RowDisabledState, type RowDisabledStateObject, RowSelectionState, type ScrollStopInfo, type Scrollbars, type ShowOverlayFn, type TableRenderRange, TreeDataSource, type TreeDataSourceProps, TreeExpandState, type TreeExpandStateValue, TreeGrid, type TreeGridOnlyProps, type TreeGridProps, TreeSelectionState, type TreeSelectionValue, type UpdateChildrenFn, type UpdateOverlayContentFn, type WaitForNodeOptions, WeakFixedSizeSet, alignNode, components, createFlashingColumnCellComponent, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, filterDataArray, defaultFilterTypes as filterTypes, flatten, buildManagedComponent as getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, multisortNested, queryKeyToCacheKey, toTreeDataArray, useManagedComponentState as useComponentState, useDataSourceInternal, useDataSourceState, useEffectWhen, useEffectWhenSameDeps, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useInfinitePortalContainer, useLayoutEffectWithChanges, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, usePrevious, useRowInfoReducers, useVisibleColumnSizes };