@infinite-table/infinite-react 4.2.1-canary.0 → 4.3.0

package/index.d.ts

@@ -1,36 +1,75 @@
 import * as React$1 from 'react';
-import React__default, { KeyboardEvent, HTMLAttributes, CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, ReactNode, EffectCallback } from 'react';
+import React__default, { CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, KeyboardEvent, HTMLAttributes, ReactNode, EffectCallback } from 'react';
 
-declare type SortDir = 1 | -1;
-declare 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;
+declare 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;
 };
-declare type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
-    field?: keyof T | (keyof T | ((item: T) => any))[];
+declare type ComponentStateGeneratedActions<T_STATE> = {
+    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
 };
-declare const multisort: {
-    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
-    knownTypes: {
-        [key: string]: (first: any, second: any) => number;
+declare type ComponentInterceptedActions<T_STATE> = {
+    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
+        actions: ComponentStateGeneratedActions<T_STATE>;
+        state: T_STATE;
+    }) => void | boolean;
+};
+declare type ComponentMappedCallbacks<T_STATE> = {
+    [k in keyof T_STATE]: (value: T_STATE[k], state: T_STATE) => {
+        callbackName: string;
+        callbackParams: any[];
     };
 };
+declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
+
+declare 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;
+};
+
+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;
+}
+declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
+
+declare type RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
+};
+
+declare type Renderable = React$1.ReactNode | JSX.Element;
 
 declare type VoidFn$1 = () => void;
 declare type Pair<KeyType, ValueType> = {
@@ -94,122 +133,6 @@ declare type InfiniteTableAction = {
     payload?: any;
 };
 
-declare type Renderable = React$1.ReactNode | JSX.Element;
-
-declare 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;
-
-declare function useInfiniteHeaderCell<T>(): {
-    dragging: boolean;
-    column: InfiniteTableComputedColumn<T>;
-    columnsMap: Map<string, InfiniteTableComputedColumn<T>>;
-    columnSortInfo: DataSourceSingleSortInfo<T> | null;
-    columnFilterValue: DataSourceFilterValueItem<T> | null;
-    selectionMode: DataSourcePropSelectionMode;
-    allRowsSelected: boolean;
-    someRowsSelected: boolean;
-    filtered: boolean;
-    api: InfiniteTableApi<T>;
-    columnApi: InfiniteTableColumnApi<T>;
-    renderBag: {
-        all?: Renderable;
-        header: Renderable;
-        sortIcon?: Renderable;
-        menuIcon?: Renderable;
-        menuIconProps?: MenuIconProps | undefined;
-        filterIcon?: Renderable;
-        selectionCheckBox?: Renderable;
-    };
-} & {
-    domRef: ((instance: HTMLElement | null) => void) | undefined;
-    insideColumnMenu: false;
-} & {
-    domRef: ((instance: HTMLElement | null) => void) | undefined;
-    insideColumnMenu: false;
-};
-
-declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T, InfiniteTableComputedColumn<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;
-};
-
-declare 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;
-
-interface ScrollPosition {
-    scrollTop: number;
-    scrollLeft: number;
-}
-declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
-
-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 const InfiniteTableClassName: string;
-declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => React$1.JSX.Element)>;
-declare 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;
-
-interface Size {
-    width: number;
-    height: number;
-}
-
 declare type InfiniteTableBaseCellProps<T> = {
     column: InfiniteTableComputedColumn<T>;
     align?: InfiniteTableColumnAlignValues;
@@ -281,6 +204,18 @@ declare type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 
+declare 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;
+
 declare type NonUndefined<T> = T extends undefined ? never : T;
 
 declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
@@ -554,16 +489,6 @@ declare type InfiniteTableComputedColumnBase<T> = {
 declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
 declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 
-interface LogFn {
-    (...args: any[]): void;
-    extend: (channelName: string) => LogFn;
-}
-declare class Logger {
-    debug: LogFn;
-    error: LogFn;
-    constructor(channelName: string);
-}
-
 declare type VoidFn = () => void;
 
 declare type FixedPosition = false | 'start' | 'end';
@@ -1090,30 +1015,6 @@ declare type PointCoords = {
     left: number;
 };
 
-declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
-    getComponentState: () => T_STATE;
-    componentState: T_STATE;
-    componentActions: T_ACTIONS;
-    assignState: (state: Partial<T_STATE>) => void;
-    replaceState: (state: T_STATE) => void;
-};
-declare type ComponentStateGeneratedActions<T_STATE> = {
-    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
-};
-declare type ComponentInterceptedActions<T_STATE> = {
-    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
-        actions: ComponentStateGeneratedActions<T_STATE>;
-        state: T_STATE;
-    }) => void | boolean;
-};
-declare type ComponentMappedCallbacks<T_STATE> = {
-    [k in keyof T_STATE]: (value: T_STATE[k], state: T_STATE) => {
-        callbackName: string;
-        callbackParams: any[];
-    };
-};
-declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
-
 declare 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]);
 };
@@ -1153,10 +1054,22 @@ declare type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT
     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 getComponentStateRoot<T_PROPS, 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>): React$1.NamedExoticComponent<T_PROPS & {
-    children: React$1.ReactNode;
-}>;
-declare function useComponentState<COMPONENT_STATE>(): ComponentStateContext<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
+declare function buildManagedComponent<T_PROPS, 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>>;
 
 declare type DataSourceStateRestoreForDetail<T> = {
     originalDataArray: DataSourceState<T>['originalDataArray'] | undefined;
@@ -1726,9 +1639,35 @@ declare type GroupBy<DataType, KeyType = any> = {
     }
 ]>;
 
-declare type RenderRange = {
-    renderStartIndex: number;
-    renderEndIndex: number;
+declare type SortDir = 1 | -1;
+declare 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;
+};
+declare type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
+    field?: keyof T | (keyof T | ((item: T) => any))[];
+};
+declare const multisort: {
+    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
 };
 
 declare type DataSourceMutation<T> = {
@@ -2052,7 +1991,7 @@ declare type DataSourcePropShouldReloadDataObject<T> = {
 declare type DataSourcePropShouldReloadData<T> = DataSourcePropShouldReloadDataObject<T>;
 declare type DataSourceProps<T> = {
     debugId?: string;
-    children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
+    children?: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
     primaryKey: keyof T | ((data: T) => string);
     /**
      * @deprecated for now
@@ -2146,6 +2085,9 @@ declare type DataSourceProps<T> = {
 } | {
     selectionMode?: false;
 });
+declare type DataSourcePropsWithChildren<T> = DataSourceProps<T> & {
+    children: NonUndefined<DataSourceProps<T>['children']>;
+};
 declare type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
 declare type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
 declare type DataSourceFilterFunctionParam<T> = {
@@ -2252,11 +2194,2065 @@ interface DataSourceAction<T> {
     payload: 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;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    filtered: boolean;
+    api: InfiniteTableApi<T>;
+    columnApi: InfiniteTableColumnApi<T>;
+    renderBag: {
+        all?: Renderable;
+        header: Renderable;
+        sortIcon?: Renderable;
+        menuIcon?: Renderable;
+        menuIconProps?: MenuIconProps | undefined;
+        filterIcon?: Renderable;
+        selectionCheckBox?: Renderable;
+    };
+} & {
+    domRef: ((instance: HTMLElement | null) => void) | undefined;
+    insideColumnMenu: false;
+} & {
+    domRef: ((instance: HTMLElement | null) => void) | undefined;
+    insideColumnMenu: false;
+};
+
+declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T, InfiniteTableComputedColumn<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;
+};
+
+declare 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 const InfiniteTableClassName: string;
+declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => React$1.JSX.Element)>;
+declare 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;
+
 declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
 
-declare function useDataSource<T>(): DataSourceState<T>;
+declare function useDataSourceState<T>(): DataSourceState<T>;
 
-declare function DataSource<T>(props: DataSourceProps<T>): React$1.JSX.Element;
+declare const useManagedDataSource: (props: unknown) => {
+    contextValue: {
+        componentState: {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        };
+        componentActions: ComponentStateGeneratedActions<{
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        }>;
+        getComponentState: () => {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        };
+        replaceState: (newState: {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        }) => void;
+        assignState: (newState: Partial<{
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        } & {
+            indexer: Indexer<unknown, any>;
+            getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+            destroyedRef: React$1.MutableRefObject<boolean>;
+            idToIndexMap: Map<any, number>;
+            detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+            stateReadyAsDetails: never;
+            cache?: never;
+            unfilteredCount: number;
+            filteredCount: number;
+            rowInfoReducerResults?: never;
+            originalDataArrayChanged: never;
+            originalDataArrayChangedInfo: {
+                timestamp: number;
+                mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+            };
+            lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+            pivotMappings?: never;
+            propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+            showSeparatePivotColumnForSingleAggregation: never;
+            dataParams?: never;
+            originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+            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;
+            dataArray: InfiniteTableRowInfo<unknown>[];
+            groupDeepMap?: never;
+            groupRowsIndexesInDataArray?: never;
+            reducerResults?: never;
+            allRowsSelected: never;
+            someRowsSelected: never;
+            pivotTotalColumnPosition: never;
+            pivotGrandTotalColumnPosition: never;
+            cursorId: never;
+            updatedAt: number;
+            reducedAt: number;
+            groupedAt: number;
+            sortedAt: number;
+            filteredAt: number;
+            generateGroupRows: never;
+            postFilterDataArray?: never;
+            postSortDataArray?: never;
+            postGroupDataArray?: never;
+            pivotColumns?: never;
+            pivotColumnGroups?: never;
+            toPrimaryKey: (data: unknown) => any;
+            operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+            sortMode: never;
+            filterMode: never;
+            groupMode: never;
+            pivotMode: never;
+            shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+            groupRowsState: GroupRowsState<unknown>;
+            multiSort: never;
+            controlledSort: never;
+            controlledFilter: never;
+            livePaginationCursor?: never;
+            lazyLoadBatchSize?: never;
+            rowSelection: never;
+            cellSelection: never;
+            selectionMode: never;
+            aggregationReducers?: never;
+            livePagination: never;
+            refetchKey: never;
+            isRowSelected: never;
+            debugId: never;
+            onDataArrayChange: never;
+            onDataMutations: 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;
+            filterValue: never;
+            filterTypes: DataSourcePropFilterTypes<unknown>;
+            primaryKey: (data: unknown) => string;
+            filterDelay: number;
+            groupBy: DataSourcePropGroupBy<unknown>;
+            pivotBy: never;
+            loading: never;
+            sortTypes: DataSourcePropSortTypes;
+            collapseGroupRowsOnDataFunctionChange: never;
+            sortInfo: never;
+        }>) => void;
+    };
+    ContextComponent: React$1.Context<ManagedComponentStateContextValue<{
+        indexer: Indexer<unknown, any>;
+        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        destroyedRef: React$1.MutableRefObject<boolean>;
+        idToIndexMap: Map<any, number>;
+        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        stateReadyAsDetails: never;
+        cache?: never;
+        unfilteredCount: number;
+        filteredCount: number;
+        rowInfoReducerResults?: never;
+        originalDataArrayChanged: never;
+        originalDataArrayChangedInfo: {
+            timestamp: number;
+            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+        };
+        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+        pivotMappings?: never;
+        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: never;
+        dataParams?: never;
+        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+        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;
+        dataArray: InfiniteTableRowInfo<unknown>[];
+        groupDeepMap?: never;
+        groupRowsIndexesInDataArray?: never;
+        reducerResults?: never;
+        allRowsSelected: never;
+        someRowsSelected: never;
+        pivotTotalColumnPosition: never;
+        pivotGrandTotalColumnPosition: never;
+        cursorId: never;
+        updatedAt: number;
+        reducedAt: number;
+        groupedAt: number;
+        sortedAt: number;
+        filteredAt: number;
+        generateGroupRows: never;
+        postFilterDataArray?: never;
+        postSortDataArray?: never;
+        postGroupDataArray?: never;
+        pivotColumns?: never;
+        pivotColumnGroups?: never;
+        toPrimaryKey: (data: unknown) => any;
+        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+        sortMode: never;
+        filterMode: never;
+        groupMode: never;
+        pivotMode: never;
+        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        groupRowsState: GroupRowsState<unknown>;
+        multiSort: never;
+        controlledSort: never;
+        controlledFilter: never;
+        livePaginationCursor?: never;
+        lazyLoadBatchSize?: never;
+        rowSelection: never;
+        cellSelection: never;
+        selectionMode: never;
+        aggregationReducers?: never;
+        livePagination: never;
+        refetchKey: never;
+        isRowSelected: never;
+        debugId: never;
+        onDataArrayChange: never;
+        onDataMutations: 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;
+        filterValue: never;
+        filterTypes: DataSourcePropFilterTypes<unknown>;
+        primaryKey: (data: unknown) => string;
+        filterDelay: number;
+        groupBy: DataSourcePropGroupBy<unknown>;
+        pivotBy: never;
+        loading: never;
+        sortTypes: DataSourcePropSortTypes;
+        collapseGroupRowsOnDataFunctionChange: never;
+        sortInfo: never;
+    } & {
+        indexer: Indexer<unknown, any>;
+        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        destroyedRef: React$1.MutableRefObject<boolean>;
+        idToIndexMap: Map<any, number>;
+        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        stateReadyAsDetails: never;
+        cache?: never;
+        unfilteredCount: number;
+        filteredCount: number;
+        rowInfoReducerResults?: never;
+        originalDataArrayChanged: never;
+        originalDataArrayChangedInfo: {
+            timestamp: number;
+            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+        };
+        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+        pivotMappings?: never;
+        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: never;
+        dataParams?: never;
+        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+        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;
+        dataArray: InfiniteTableRowInfo<unknown>[];
+        groupDeepMap?: never;
+        groupRowsIndexesInDataArray?: never;
+        reducerResults?: never;
+        allRowsSelected: never;
+        someRowsSelected: never;
+        pivotTotalColumnPosition: never;
+        pivotGrandTotalColumnPosition: never;
+        cursorId: never;
+        updatedAt: number;
+        reducedAt: number;
+        groupedAt: number;
+        sortedAt: number;
+        filteredAt: number;
+        generateGroupRows: never;
+        postFilterDataArray?: never;
+        postSortDataArray?: never;
+        postGroupDataArray?: never;
+        pivotColumns?: never;
+        pivotColumnGroups?: never;
+        toPrimaryKey: (data: unknown) => any;
+        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+        sortMode: never;
+        filterMode: never;
+        groupMode: never;
+        pivotMode: never;
+        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        groupRowsState: GroupRowsState<unknown>;
+        multiSort: never;
+        controlledSort: never;
+        controlledFilter: never;
+        livePaginationCursor?: never;
+        lazyLoadBatchSize?: never;
+        rowSelection: never;
+        cellSelection: never;
+        selectionMode: never;
+        aggregationReducers?: never;
+        livePagination: never;
+        refetchKey: never;
+        isRowSelected: never;
+        debugId: never;
+        onDataArrayChange: never;
+        onDataMutations: 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;
+        filterValue: never;
+        filterTypes: DataSourcePropFilterTypes<unknown>;
+        primaryKey: (data: unknown) => string;
+        filterDelay: number;
+        groupBy: DataSourcePropGroupBy<unknown>;
+        pivotBy: never;
+        loading: never;
+        sortTypes: DataSourcePropSortTypes;
+        collapseGroupRowsOnDataFunctionChange: never;
+        sortInfo: never;
+    } & {
+        indexer: Indexer<unknown, any>;
+        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        destroyedRef: React$1.MutableRefObject<boolean>;
+        idToIndexMap: Map<any, number>;
+        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        stateReadyAsDetails: never;
+        cache?: never;
+        unfilteredCount: number;
+        filteredCount: number;
+        rowInfoReducerResults?: never;
+        originalDataArrayChanged: never;
+        originalDataArrayChangedInfo: {
+            timestamp: number;
+            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+        };
+        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+        pivotMappings?: never;
+        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: never;
+        dataParams?: never;
+        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+        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;
+        dataArray: InfiniteTableRowInfo<unknown>[];
+        groupDeepMap?: never;
+        groupRowsIndexesInDataArray?: never;
+        reducerResults?: never;
+        allRowsSelected: never;
+        someRowsSelected: never;
+        pivotTotalColumnPosition: never;
+        pivotGrandTotalColumnPosition: never;
+        cursorId: never;
+        updatedAt: number;
+        reducedAt: number;
+        groupedAt: number;
+        sortedAt: number;
+        filteredAt: number;
+        generateGroupRows: never;
+        postFilterDataArray?: never;
+        postSortDataArray?: never;
+        postGroupDataArray?: never;
+        pivotColumns?: never;
+        pivotColumnGroups?: never;
+        toPrimaryKey: (data: unknown) => any;
+        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+        sortMode: never;
+        filterMode: never;
+        groupMode: never;
+        pivotMode: never;
+        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        groupRowsState: GroupRowsState<unknown>;
+        multiSort: never;
+        controlledSort: never;
+        controlledFilter: never;
+        livePaginationCursor?: never;
+        lazyLoadBatchSize?: never;
+        rowSelection: never;
+        cellSelection: never;
+        selectionMode: never;
+        aggregationReducers?: never;
+        livePagination: never;
+        refetchKey: never;
+        isRowSelected: never;
+        debugId: never;
+        onDataArrayChange: never;
+        onDataMutations: 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;
+        filterValue: never;
+        filterTypes: DataSourcePropFilterTypes<unknown>;
+        primaryKey: (data: unknown) => string;
+        filterDelay: number;
+        groupBy: DataSourcePropGroupBy<unknown>;
+        pivotBy: never;
+        loading: never;
+        sortTypes: DataSourcePropSortTypes;
+        collapseGroupRowsOnDataFunctionChange: never;
+        sortInfo: never;
+    }, ComponentStateGeneratedActions<{
+        indexer: Indexer<unknown, any>;
+        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        destroyedRef: React$1.MutableRefObject<boolean>;
+        idToIndexMap: Map<any, number>;
+        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        stateReadyAsDetails: never;
+        cache?: never;
+        unfilteredCount: number;
+        filteredCount: number;
+        rowInfoReducerResults?: never;
+        originalDataArrayChanged: never;
+        originalDataArrayChangedInfo: {
+            timestamp: number;
+            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+        };
+        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+        pivotMappings?: never;
+        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: never;
+        dataParams?: never;
+        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+        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;
+        dataArray: InfiniteTableRowInfo<unknown>[];
+        groupDeepMap?: never;
+        groupRowsIndexesInDataArray?: never;
+        reducerResults?: never;
+        allRowsSelected: never;
+        someRowsSelected: never;
+        pivotTotalColumnPosition: never;
+        pivotGrandTotalColumnPosition: never;
+        cursorId: never;
+        updatedAt: number;
+        reducedAt: number;
+        groupedAt: number;
+        sortedAt: number;
+        filteredAt: number;
+        generateGroupRows: never;
+        postFilterDataArray?: never;
+        postSortDataArray?: never;
+        postGroupDataArray?: never;
+        pivotColumns?: never;
+        pivotColumnGroups?: never;
+        toPrimaryKey: (data: unknown) => any;
+        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+        sortMode: never;
+        filterMode: never;
+        groupMode: never;
+        pivotMode: never;
+        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        groupRowsState: GroupRowsState<unknown>;
+        multiSort: never;
+        controlledSort: never;
+        controlledFilter: never;
+        livePaginationCursor?: never;
+        lazyLoadBatchSize?: never;
+        rowSelection: never;
+        cellSelection: never;
+        selectionMode: never;
+        aggregationReducers?: never;
+        livePagination: never;
+        refetchKey: never;
+        isRowSelected: never;
+        debugId: never;
+        onDataArrayChange: never;
+        onDataMutations: 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;
+        filterValue: never;
+        filterTypes: DataSourcePropFilterTypes<unknown>;
+        primaryKey: (data: unknown) => string;
+        filterDelay: number;
+        groupBy: DataSourcePropGroupBy<unknown>;
+        pivotBy: never;
+        loading: never;
+        sortTypes: DataSourcePropSortTypes;
+        collapseGroupRowsOnDataFunctionChange: never;
+        sortInfo: never;
+    } & {
+        indexer: Indexer<unknown, any>;
+        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        destroyedRef: React$1.MutableRefObject<boolean>;
+        idToIndexMap: Map<any, number>;
+        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        stateReadyAsDetails: never;
+        cache?: never;
+        unfilteredCount: number;
+        filteredCount: number;
+        rowInfoReducerResults?: never;
+        originalDataArrayChanged: never;
+        originalDataArrayChangedInfo: {
+            timestamp: number;
+            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+        };
+        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+        pivotMappings?: never;
+        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: never;
+        dataParams?: never;
+        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+        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;
+        dataArray: InfiniteTableRowInfo<unknown>[];
+        groupDeepMap?: never;
+        groupRowsIndexesInDataArray?: never;
+        reducerResults?: never;
+        allRowsSelected: never;
+        someRowsSelected: never;
+        pivotTotalColumnPosition: never;
+        pivotGrandTotalColumnPosition: never;
+        cursorId: never;
+        updatedAt: number;
+        reducedAt: number;
+        groupedAt: number;
+        sortedAt: number;
+        filteredAt: number;
+        generateGroupRows: never;
+        postFilterDataArray?: never;
+        postSortDataArray?: never;
+        postGroupDataArray?: never;
+        pivotColumns?: never;
+        pivotColumnGroups?: never;
+        toPrimaryKey: (data: unknown) => any;
+        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+        sortMode: never;
+        filterMode: never;
+        groupMode: never;
+        pivotMode: never;
+        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        groupRowsState: GroupRowsState<unknown>;
+        multiSort: never;
+        controlledSort: never;
+        controlledFilter: never;
+        livePaginationCursor?: never;
+        lazyLoadBatchSize?: never;
+        rowSelection: never;
+        cellSelection: never;
+        selectionMode: never;
+        aggregationReducers?: never;
+        livePagination: never;
+        refetchKey: never;
+        isRowSelected: never;
+        debugId: never;
+        onDataArrayChange: never;
+        onDataMutations: 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;
+        filterValue: never;
+        filterTypes: DataSourcePropFilterTypes<unknown>;
+        primaryKey: (data: unknown) => string;
+        filterDelay: number;
+        groupBy: DataSourcePropGroupBy<unknown>;
+        pivotBy: never;
+        loading: never;
+        sortTypes: DataSourcePropSortTypes;
+        collapseGroupRowsOnDataFunctionChange: never;
+        sortInfo: never;
+    } & {
+        indexer: Indexer<unknown, any>;
+        getDataSourceMasterContextRef: React$1.MutableRefObject<() => DataSourceMasterDetailContextValue<any> | undefined>;
+        destroyedRef: React$1.MutableRefObject<boolean>;
+        idToIndexMap: Map<any, number>;
+        detailDataSourcesStateToRestore: Map<any, Partial<DataSourceStateRestoreForDetail<any>>>;
+        stateReadyAsDetails: never;
+        cache?: never;
+        unfilteredCount: number;
+        filteredCount: number;
+        rowInfoReducerResults?: never;
+        originalDataArrayChanged: never;
+        originalDataArrayChangedInfo: {
+            timestamp: number;
+            mutations?: Map<string, DataSourceMutation<unknown>[]> | undefined;
+        };
+        lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+        pivotMappings?: never;
+        propsCache: Map<"children" | "data" | "groupBy" | "pivotBy" | "rowSelection" | "sortMode" | "filterMode" | "groupMode" | "shouldReloadData" | "groupRowsState" | "livePaginationCursor" | "cellSelection" | "selectionMode" | "aggregationReducers" | "livePagination" | "refetchKey" | "isRowSelected" | "debugId" | "onDataArrayChange" | "onDataMutations" | "onReady" | "rowInfoReducers" | "lazyLoad" | "useGroupKeysForMultiRowSelection" | "onDataParamsChange" | "sortFunction" | "filterFunction" | "filterValue" | "filterTypes" | "primaryKey" | "filterDelay" | "loading" | "sortTypes" | "collapseGroupRowsOnDataFunctionChange" | "sortInfo" | "fields" | "defaultRowSelection" | "defaultCellSelection" | "onCellSelectionChange" | "defaultLoading" | "onLoadingChange" | "defaultPivotBy" | "onPivotByChange" | "defaultAggregationReducers" | "defaultGroupBy" | "onGroupByChange" | "defaultGroupRowsState" | "onGroupRowsStateChange" | "defaultSortInfo" | "onSortInfoChange" | "onLivePaginationCursorChange" | "defaultFilterValue" | "onFilterValueChange", WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: never;
+        dataParams?: never;
+        originalLazyGroupData: LazyGroupDataDeepMap<unknown, string>;
+        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;
+        dataArray: InfiniteTableRowInfo<unknown>[];
+        groupDeepMap?: never;
+        groupRowsIndexesInDataArray?: never;
+        reducerResults?: never;
+        allRowsSelected: never;
+        someRowsSelected: never;
+        pivotTotalColumnPosition: never;
+        pivotGrandTotalColumnPosition: never;
+        cursorId: never;
+        updatedAt: number;
+        reducedAt: number;
+        groupedAt: number;
+        sortedAt: number;
+        filteredAt: number;
+        generateGroupRows: never;
+        postFilterDataArray?: never;
+        postSortDataArray?: never;
+        postGroupDataArray?: never;
+        pivotColumns?: never;
+        pivotColumnGroups?: never;
+        toPrimaryKey: (data: unknown) => any;
+        operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<unknown>>>;
+        sortMode: never;
+        filterMode: never;
+        groupMode: never;
+        pivotMode: never;
+        shouldReloadData: Required<DataSourcePropShouldReloadData<unknown>>;
+        groupRowsState: GroupRowsState<unknown>;
+        multiSort: never;
+        controlledSort: never;
+        controlledFilter: never;
+        livePaginationCursor?: never;
+        lazyLoadBatchSize?: never;
+        rowSelection: never;
+        cellSelection: never;
+        selectionMode: never;
+        aggregationReducers?: never;
+        livePagination: never;
+        refetchKey: never;
+        isRowSelected: never;
+        debugId: never;
+        onDataArrayChange: never;
+        onDataMutations: 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;
+        filterValue: never;
+        filterTypes: DataSourcePropFilterTypes<unknown>;
+        primaryKey: (data: unknown) => string;
+        filterDelay: number;
+        groupBy: DataSourcePropGroupBy<unknown>;
+        pivotBy: never;
+        loading: never;
+        sortTypes: DataSourcePropSortTypes;
+        collapseGroupRowsOnDataFunctionChange: never;
+        sortInfo: never;
+    }>>>;
+};
+declare function DataSource<T>(props: DataSourcePropsWithChildren<T>): React$1.JSX.Element;
 declare function useRowInfoReducers(): Record<string, any> | undefined;
 declare function useMasterRowInfo<T = any>(): InfiniteTableRowInfo<T> | undefined;
 
@@ -3273,6 +5269,71 @@ declare function debounce(fn: Function, { wait }: {
     wait: number;
 }): (...args: any[]) => void;
 
+declare type DataSourceChildren<T> = React$1.ReactNode | ((values: DataSourceState<T>) => React$1.ReactNode);
+
+declare function useDataSourceInternal<T>(props: Omit<DataSourceProps<T>, 'children'>): {
+    DataSource: ({ children }: {
+        children: DataSourceChildren<T>;
+    }) => React__default.JSX.Element;
+    state: DataSourceState<T>;
+};
+
+declare 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;
+    constructor(debugName?: string);
+    fetch: (loadFn: DataQueryFn, ...key: DataQueryKey[]) => Promise<DataQuerySnapshot>;
+    getCurrentSnapshot: () => DataQuerySnapshot;
+    getDoneSnapshot: () => Promise<DataQuerySnapshot>;
+    getResult: () => any;
+    isDone: () => boolean;
+    isSuccess: () => boolean;
+}
+declare type DataQueryKey = string | number | boolean | null | symbol | {
+    [key: string]: DataQueryKey | undefined;
+} | Array<DataQueryKey>;
+declare type DataQueryFn = (...key: DataQueryKey[]) => Promise<any>;
+
+declare 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;
+}
+declare type DataClientOptions = {
+    name: string;
+    cache?: boolean;
+};
+
 declare function Menu(props: MenuProps & HTMLProps<HTMLDivElement>): React$1.JSX.Element;
 
 declare function useEffectWithChanges<T>(fn: (changes: Record<keyof T, any>, prevValues: Record<string, any>) => void | (() => void), deps: Record<keyof T, any>): void;
@@ -3325,23 +5386,6 @@ declare class WeakFixedSizeSet<T extends object> {
     add(el: T): this;
 }
 
-declare 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'];
-};
-
 declare const components: {
     CheckBox: typeof InfiniteCheckBox;
     LoadMask: (props: LoadMaskProps) => React$1.JSX.Element;
@@ -3350,4 +5394,4 @@ declare const components: {
     NumberFilterEditor: typeof NumberFilterEditor;
 };
 
-export { AdvancedAlignable, CellSelectionState, CellSelectionStateObject, ColumnTypeWithInherit, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceApi, DataSourceCRUDParam, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceInsertParam, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourceMasterDetailContextValue, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropCellSelection_MultiCell, DataSourcePropCellSelection_SingleCell, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnCellSelectionChange_MultiCell, DataSourcePropOnCellSelectionChange_SingleCell, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropPivotBy, DataSourcePropRowInfoReducers, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropShouldReloadData, DataSourcePropShouldReloadDataObject, DataSourcePropSortFn, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourceRawReducer, DataSourceRemoteData, DataSourceRowInfoReducer, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, DebugLogger, DeepMap, ElementContainerGetter, FixedSizeSet, GroupRowsState, InfiniteColumnEditorContextType, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnApi, InfiniteTableColumnCellContextType, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderFunctionForGroupRows, InfiniteTableColumnRenderFunctionForNormalRows, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnValueFormatterParams, InfiniteTableColumnValueGetterParams, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropGetCellContextMenuItems, InfiniteTablePropGetColumnMenuItems, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropKeyboardShorcut, InfiniteTablePropMultiSortBehavior, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, InfiniteTable_HasGrouping_RowInfoGroup, InfiniteTable_HasGrouping_RowInfoNormal, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, Menu, MenuChildrenFnParam, MenuColumn, MenuColumnRenderParam, MenuDecoration, MenuIconProps, MenuItemActionContext, MenuItemDefinition, MenuItemObject, MenuProps, MenuRenderable, MenuRuntimeItem, MenuRuntimeItemSelectable, MenuSeparator, OverlayShowParams, RowDetailCache, RowDetailState, RowDetailStateObject, RowSelectionState, Scrollbars, ShowOverlayFn, WeakFixedSizeSet, components, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, defaultFilterTypes as filterTypes, flatten, getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, useComponentState, useDataSource, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useMasterRowInfo, useOverlay, useOverlayPortal, useRowInfoReducers, useVisibleColumnSizes };
+export { AdvancedAlignable, CellSelectionState, CellSelectionStateObject, ColumnTypeWithInherit, DataClient, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceApi, DataSourceCRUDParam, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceInsertParam, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourceMasterDetailContextValue, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropCellSelection, DataSourcePropCellSelection_MultiCell, DataSourcePropCellSelection_SingleCell, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnCellSelectionChange_MultiCell, DataSourcePropOnCellSelectionChange_SingleCell, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropPivotBy, DataSourcePropRowInfoReducers, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropShouldReloadData, DataSourcePropShouldReloadDataObject, DataSourcePropSortFn, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourcePropsWithChildren, DataSourceRawReducer, DataSourceRemoteData, DataSourceRowInfoReducer, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, DebugLogger, DeepMap, ElementContainerGetter, FixedSizeSet, GroupRowsState, InfiniteColumnEditorContextType, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnApi, InfiniteTableColumnCellContextType, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderFunctionForGroupRows, InfiniteTableColumnRenderFunctionForNormalRows, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnValueFormatterParams, InfiniteTableColumnValueGetterParams, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropGetCellContextMenuItems, InfiniteTablePropGetColumnMenuItems, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropKeyboardShorcut, InfiniteTablePropMultiSortBehavior, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, InfiniteTable_HasGrouping_RowInfoGroup, InfiniteTable_HasGrouping_RowInfoNormal, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, Menu, MenuChildrenFnParam, MenuColumn, MenuColumnRenderParam, MenuDecoration, MenuIconProps, MenuItemActionContext, MenuItemDefinition, MenuItemObject, MenuProps, MenuRenderable, MenuRuntimeItem, MenuRuntimeItemSelectable, MenuSeparator, OverlayShowParams, RowDetailCache, RowDetailState, RowDetailStateObject, RowSelectionState, Scrollbars, ShowOverlayFn, WeakFixedSizeSet, components, debounce, debug, defaultFilterTypes, eventMatchesKeyboardShortcut, defaultFilterTypes as filterTypes, flatten, buildManagedComponent as getComponentStateRoot, group, interceptMap, keyboardShortcuts, multisort, queryKeyToCacheKey, useManagedComponentState as useComponentState, useDataSourceInternal, useDataSourceState, useEffectWithChanges, useEffectWithObject, useGridScroll, useInfiniteColumnCell, useInfiniteColumnEditor, useInfiniteColumnFilterEditor, useInfiniteHeaderCell, useManagedDataSource, useMasterRowInfo, useOverlay, useOverlayPortal, useRowInfoReducers, useVisibleColumnSizes };