@infinite-table/infinite-react 0.1.2 → 0.2.1

package/index.d.ts

@@ -49,18 +49,14 @@ declare module "utils/multisort/index" {
     const getMultisortFunction: <T>(sortInfo: MultisortInfo<T>[], get?: ((item: any) => T) | undefined) => (first: T, second: T) => number;
     export { getMultisortFunction, getSortFunctions };
 }
-declare module "components/hooks/useOnce" {
+declare module "utils/DeepMap/once" {
     export function once<ReturnType>(fn: () => ReturnType): () => ReturnType;
-    export function useOnce<ReturnType>(fn: () => ReturnType): ReturnType;
-}
-declare module "components/types/VoidFn" {
-    export type VoidFn = () => void;
 }
-declare module "utils/sortAscending" {
+declare module "utils/DeepMap/sortAscending" {
     export const sortAscending: (a: number, b: number) => number;
 }
-declare module "utils/DeepMap" {
-    import { VoidFn } from "components/types/VoidFn";
+declare module "utils/DeepMap/index" {
+    type VoidFn = () => void;
     type Pair<KeyType, ValueType> = {
         value?: ValueType;
         map?: Map<KeyType, Pair<KeyType, ValueType>>;
@@ -149,7 +145,7 @@ declare module "components/hooks/useComponentState" {
         [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
             actions: ComponentStateGeneratedActions<T_STATE>;
             state: T_STATE;
-        }) => void;
+        }) => void | boolean;
     };
     export type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
     export type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT> = Partial<{
@@ -161,6 +157,11 @@ declare module "components/hooks/useComponentState" {
         forwardProps?: (setupState: COMPONENT_SETUP_STATE) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE>;
         allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
         interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
+        onPropChange?: (params: {
+            name: keyof T_PROPS;
+            oldValue: any;
+            newValue: any;
+        }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>) => void;
         mapPropsToState?: (params: {
             props: T_PROPS;
             state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>;
@@ -185,6 +186,9 @@ declare module "components/hooks/useComponentState" {
 declare module "components/types/NonUndefined" {
     export type NonUndefined<T> = T extends undefined ? never : T;
 }
+declare module "components/types/VoidFn" {
+    export type VoidFn = () => void;
+}
 declare module "components/types/SubscriptionCallback" {
     import { VoidFn } from "components/types/VoidFn";
     export type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
@@ -195,10 +199,107 @@ declare module "components/types/SubscriptionCallback" {
         onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
     }
 }
+declare module "components/types/Size" {
+    export interface Size {
+        width: number;
+        height: number;
+    }
+    export type OnResizeFn = (size: {
+        width: number;
+        height: number;
+    }) => void;
+}
+declare module "components/VirtualBrain/index" {
+    import { Logger } from "utils/debug";
+    import { Size } from "components/types/Size";
+    import type { OnScrollFn, ScrollPosition } from "components/types/ScrollPosition";
+    type MainAxisOptions = 'vertical' | 'horizontal';
+    export type VirtualBrainOptions = {
+        mainAxis: MainAxisOptions;
+        itemSize: MainAxisSize;
+        itemSpan?: ({ itemIndex }: {
+            itemIndex: number;
+        }) => number;
+        count: number;
+        name?: string;
+    };
+    export type MainAxisSize = number | ((itemIndex: number) => number);
+    type OnRenderCountChangeFn = (renderCount: number) => void;
+    type OnSizeChangeFn = (size: number) => void;
+    type OnDestroyFn = () => void;
+    export type GetItemPositionFn = (itemIndex: number) => number;
+    export type RenderRange = {
+        renderStartIndex: number;
+        renderEndIndex: number;
+    };
+    export type OnRenderRangeChangeFn = (renderRange: RenderRange) => void;
+    export class VirtualBrain extends Logger {
+        private scrollPosition;
+        private scrollPositionOnMainAxis;
+        private itemSpanParent;
+        private itemSpanValue;
+        private itemSizeCache;
+        private itemOffsetCache;
+        private options;
+        private destroyed;
+        private totalSize;
+        private onScrollFns;
+        private onTotalSizeChangeFns;
+        private onRenderCountChangeFns;
+        private onRenderRangeChangeFns;
+        private onDestroyFns;
+        name: string | undefined;
+        private renderCount;
+        private renderRange;
+        private availableSize;
+        constructor(options: VirtualBrainOptions);
+        setAvailableSize: (size: Size) => void;
+        getOptions(): VirtualBrainOptions;
+        private updateRenderCount;
+        private computeRenderCount;
+        private setRenderCount;
+        private updateRenderRange;
+        getRenderStartIndex(): number;
+        getRenderCount: () => number;
+        setScrollPosition: (scrollPosition: ScrollPosition) => void;
+        private notifyScrollChange;
+        private notifyDestroy;
+        private notifyTotalSizeChange;
+        private notifyRenderCountChange;
+        private notifyRenderRangeChange;
+        getRenderRange: () => RenderRange;
+        private setRenderRange;
+        private computeRenderRange;
+        getScrollPosition: () => ScrollPosition;
+        onScroll: (fn: OnScrollFn) => () => void;
+        onTotalSizeChange: (fn: OnSizeChangeFn) => () => void;
+        onRenderCountChange: (fn: OnRenderCountChangeFn) => () => void;
+        onRenderRangeChange: (fn: OnRenderRangeChangeFn) => () => void;
+        onDestroy: (fn: OnDestroyFn) => () => void;
+        update: (newCount: VirtualBrainOptions['count'], newItemSize: VirtualBrainOptions['itemSize'], newItemSpan?: VirtualBrainOptions['itemSpan']) => void;
+        private reset;
+        private computeItemSpanUpTo;
+        private computeCacheFor;
+        private getItemSizeCacheFor;
+        getItemSpan: (itemIndex: number) => number;
+        getItemSpanParent: (itemIndex: number) => number;
+        getItemSizeWithSpan: (itemIndex: number, itemSpan: number) => number;
+        /**
+         * For now, this doesn't take into account the itemspan, and it's okay not to
+         * @param itemIndex
+         * @returns the size of the specified item
+         */
+        getItemSize: (itemIndex: number) => number;
+        getTotalSize: () => number;
+        getItemAt: (scrollPos: number) => number;
+        getItemOffsetFor: (itemIndex: number) => number;
+        destroy: () => void;
+    }
+}
 declare module "components/DataSource/types" {
     import * as React from 'react';
     import { MultisortInfo } from "utils/multisort/index";
-    import { DeepMap } from "utils/DeepMap";
+    import { DeepMap } from "utils/DeepMap/index";
     import { DeepMapGroupValueType, GroupBy, GroupKeyType, PivotBy } from "utils/groupAndPivot/index";
     import { InfiniteTableColumn, InfiniteTableColumnGroup, InfiniteTableRowInfo, Scrollbars } from "components/InfiniteTable/index";
     import { ComponentStateActions } from "components/hooks/useComponentState";
@@ -206,15 +307,22 @@ declare module "components/DataSource/types" {
     import { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
     import { NonUndefined } from "components/types/NonUndefined";
     import { SubscriptionCallback } from "components/types/SubscriptionCallback";
+    import { ScrollStopInfo } from "components/InfiniteTable/types/InfiniteTableProps";
+    import { RenderRange } from "components/VirtualBrain/index";
     export interface DataSourceDataParams<T> {
         originalDataArray: T[];
         sortInfo?: DataSourceSortInfo<T>;
         groupBy?: DataSourcePropGroupBy<T>;
         pivotBy?: DataSourcePropPivotBy<T>;
+        lazyLoadBatchSize?: number;
+        lazyLoadStartIndex?: number;
+        groupKeys?: any[];
+        aggregationReducers?: DataSourcePropAggregationReducers<T>;
         livePaginationCursor?: DataSourceLivePaginationCursorValue;
+        cursorId?: DataSourceSetupState<T>['cursorId'];
         changes?: DataSourceDataParamsChanges<T>;
     }
-    export type DataSourceDataParamsChanges<T> = Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>;
+    export type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
     export type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
         field?: keyof T;
         id?: string;
@@ -224,6 +332,8 @@ declare module "components/DataSource/types" {
     export type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
     export type DataSourceRemoteData<T> = {
         data: T[];
+        mappings?: DataSourceMappings;
+        totalCount?: number;
         livePaginationCursor?: DataSourceLivePaginationCursorValue;
     };
     export type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
@@ -237,6 +347,8 @@ declare module "components/DataSource/types" {
     export interface DataSourceMappedState<T> {
         aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
         livePagination: DataSourceProps<T>['livePagination'];
+        fullLazyLoad: DataSourceProps<T>['fullLazyLoad'];
+        lazyLoadBatchSize: DataSourceProps<T>['lazyLoadBatchSize'];
         onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
         data: DataSourceProps<T>['data'];
         primaryKey: DataSourceProps<T>['primaryKey'];
@@ -244,27 +356,50 @@ declare module "components/DataSource/types" {
         groupRowsState: NonUndefined<DataSourceProps<T>['groupRowsState']>;
         pivotBy: DataSourceProps<T>['pivotBy'];
         loading: NonUndefined<DataSourceProps<T>['loading']>;
+        collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
         sortInfo: DataSourceSingleSortInfo<T>[] | null;
     }
     export type DataSourceAggregationReducer<T, AggregationResultType> = {
+        name?: string;
         field?: keyof T;
-        initialValue: AggregationResultType;
+        initialValue?: AggregationResultType;
         getter?: (data: T) => any;
-        reducer: (accumulator: any, value: any, data: T) => AggregationResultType | any;
+        reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
         done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
     };
+    export type DataSourceMappings = Record<'totals' | 'values', string>;
+    export type LazyGroupDataItem<DataType> = {
+        data: Partial<DataType>;
+        keys: any[];
+        aggregations?: Record<string, any>;
+        pivot?: {
+            values: Record<string, any>;
+            totals?: Record<string, any>;
+        };
+    };
+    export type LazyGroupRowInfo<DataType> = {
+        items: LazyGroupDataItem<DataType>[];
+        totalCount: number;
+    };
+    export type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyGroupRowInfo<DataType>>;
     export interface DataSourceSetupState<T> {
+        pivotMappings?: DataSourceMappings;
         propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
         showSeparatePivotColumnForSingleAggregation: boolean;
         dataParams?: DataSourceDataParams<T>;
+        originalLazyGroupData: LazyGroupDataDeepMap<T>;
+        originalLazyGroupDataChangeDetect: number | string;
+        scrollStopDelayUpdatedByTable: number;
         notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
+        notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
+        notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
         originalDataArray: T[];
         lastSortDataArray?: T[];
         lastGroupDataArray?: InfiniteTableRowInfo<T>[];
         dataArray: InfiniteTableRowInfo<T>[];
         groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
         pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
-        scrollBottomId: number | Symbol | DataSourceLivePaginationCursorValue;
+        cursorId: number | Symbol | DataSourceLivePaginationCursorValue;
         updatedAt: number;
         reducedAt: number;
         groupedAt: number;
@@ -276,11 +411,13 @@ declare module "components/DataSource/types" {
         pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
     }
     export type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
-    export interface DataSourceProps<T> {
+    export type DataSourceProps<T> = {
         children: React.ReactNode | ((contextData: DataSourceState<T>) => React.ReactNode);
         primaryKey: keyof T;
         fields?: (keyof T)[];
         data: DataSourceData<T>;
+        fullLazyLoad?: boolean;
+        lazyLoadBatchSize?: number;
         loading?: boolean;
         defaultLoading?: boolean;
         onLoadingChange?: (loading: boolean) => void;
@@ -295,6 +432,7 @@ declare module "components/DataSource/types" {
         groupRowsState?: GroupRowsState;
         defaultGroupRowsState?: GroupRowsState;
         onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
+        collapseGroupRowsOnDataFunctionChange?: boolean;
         sortInfo?: DataSourceSortInfo<T>;
         defaultSortInfo?: DataSourceSortInfo<T>;
         onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
@@ -302,7 +440,7 @@ declare module "components/DataSource/types" {
         livePagination?: boolean;
         livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
         onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
-    }
+    };
     export type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
     export type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
     export type DataSourceLivePaginationCursorParams<T> = {
@@ -346,16 +484,25 @@ declare module "components/DataSource/publicHooks/useDataSource" {
     export function useDataSource<T>(): DataSourceState<T>;
     export function useDataSourceContextValue<T>(): DataSourceContextValue<T>;
 }
+declare module "utils/getGlobal" {
+    export function getGlobal<T extends Window>(): T;
+}
 declare module "components/hooks/useEffectWithChanges" {
     import { EffectCallback } from 'react';
     export function useEffectWithChanges(fn: (changes: Record<string, any>, prevValues: Record<string, any>) => void | (() => void), deps: Record<string, any>): void;
     export function useEffectWithObject(fn: EffectCallback, deps: Record<string, any>): void;
 }
+declare module "components/utils/debounce" {
+    export function debounce(fn: Function, { wait }: {
+        wait: number;
+    }): (...args: any[]) => void;
+}
 declare module "components/DataSource/privateHooks/useLoadData" {
-    import { DataSourceDataParams, DataSourceState, DataSourceDataParamsChanges } from "components/DataSource/types";
-    export function buildDataSourceDataParams<T>(componentState: DataSourceState<T>, changes?: DataSourceDataParamsChanges<T>): DataSourceDataParams<T>;
+    import { ComponentStateGeneratedActions } from "components/hooks/useComponentState";
+    import { DataSourceDataParams, DataSourceData, DataSourceState } from "components/DataSource/types";
+    export function buildDataSourceDataParams<T>(componentState: DataSourceState<T>, overrides?: Partial<DataSourceDataParams<T>>): DataSourceDataParams<T>;
+    export function loadData<T>(data: DataSourceData<T>, componentState: DataSourceState<T>, actions: ComponentStateGeneratedActions<DataSourceState<T>>, overrides?: Partial<DataSourceDataParams<T>>): Promise<void>;
     export function useLoadData<T>(): void;
-    export function useLivePagination<T>(): void;
 }
 declare module "components/DataSource/state/normalizeSortInfo" {
     import { DataSourceSingleSortInfo, DataSourceSortInfo } from "components/DataSource/types";
@@ -366,7 +513,7 @@ declare module "components/utils/buildSubscriptionCallback" {
     export function buildSubscriptionCallback<T>(): SubscriptionCallback<T>;
 }
 declare module "utils/shallowEqualObjects" {
-    export function shallowEqualObjects<T extends object | null>(objA: T, objB: T): boolean;
+    export function shallowEqualObjects<T extends object | null>(objA: T, objB: T, ignoreKeys?: Set<string>): boolean;
 }
 declare module "components/utils/discardCallsWithEqualArg" {
     export function discardCallsWithEqualArg<T = any>(fn: (arg: T) => void, timeframe?: number, getCompareObject?: (arg: T) => any): (arg: T) => void;
@@ -375,7 +522,8 @@ declare module "components/DataSource/state/getInitialState" {
     import { DataSourceMappedState, DataSourceProps, DataSourceDerivedState, DataSourceSetupState, DataSourceState } from "components/DataSource/types";
     import { GroupRowsState } from "components/DataSource/GroupRowsState";
     import { ComponentInterceptedActions, ForwardPropsToStateFnResult } from "components/hooks/useComponentState";
-    import { DataSourceDataParams } from "components/DataSource/index";
+    import { DataSourceComponentActions, DataSourceDataParams } from "components/DataSource/index";
+    export const defaultCursorId: unique symbol;
     export function initSetupState<T>(): DataSourceSetupState<T>;
     export const forwardProps: <T>(setupState: DataSourceSetupState<T>) => Partial<{
         data: 1 | ((value: import("components/DataSource").DataSourceData<T>) => import("components/DataSource").DataSourceData<T>);
@@ -383,16 +531,24 @@ declare module "components/DataSource/state/getInitialState" {
         sortInfo: 1 | ((value: import("components/DataSource").DataSourceSortInfo<T> | undefined) => import("components/DataSource").DataSourceSingleSortInfo<T>[] | null);
         groupBy: 1 | ((value: import("components/DataSource").DataSourcePropGroupBy<T> | undefined) => import("components/DataSource").DataSourcePropGroupBy<T>);
         pivotBy: 1 | ((value: import("components/DataSource").DataSourcePropPivotBy<T> | undefined) => import("components/DataSource").DataSourcePropPivotBy<T> | undefined);
+        lazyLoadBatchSize: 1 | ((value: number | undefined) => number | undefined);
         aggregationReducers: 1 | ((value: import("components/DataSource").DataSourcePropAggregationReducers<T> | undefined) => import("components/DataSource").DataSourcePropAggregationReducers<T> | undefined);
         livePagination: 1 | ((value: boolean | undefined) => boolean | undefined);
+        fullLazyLoad: 1 | ((value: boolean | undefined) => boolean | undefined);
         onDataParamsChange: 1 | ((value: ((dataParamsChange: DataSourceDataParams<T>) => void) | undefined) => ((dataParamsChange: DataSourceDataParams<T>) => void) | undefined);
         primaryKey: 1 | ((value: keyof T) => keyof T);
         groupRowsState: 1 | ((value: GroupRowsState<any> | undefined) => GroupRowsState<any>);
+        collapseGroupRowsOnDataFunctionChange: 1 | ((value: boolean | undefined) => boolean);
     }>;
     export function mapPropsToState<T extends any>(params: {
         props: DataSourceProps<T>;
         state: DataSourceState<T>;
+        oldState: DataSourceState<T> | null;
     }): DataSourceDerivedState<T>;
+    export function onPropChange<T>(params: {
+        name: keyof T;
+        newValue: any;
+    }, props: DataSourceProps<T>, actions: DataSourceComponentActions<T>): void;
     export function getInterceptActions<T>(): ComponentInterceptedActions<DataSourceState<T>>;
 }
 declare module "components/types/Renderable" {
@@ -424,6 +580,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
     import type { InfiniteTableColumnGroup, InfiniteTableRowInfo } from "components/InfiniteTable/types/index";
     import { CSSProperties } from 'react';
     import { AggregationReducer, InfiniteTableRowInfoGroup, InfiniteTableRowInfoNormal, PivotBy } from "utils/groupAndPivot/index";
+    import { InfiniteTableColumnPinnedValues } from "components/InfiniteTable/types/InfiniteTableProps";
     export type { DiscriminatedUnion, RequireAtLeastOne };
     export type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
     export type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
@@ -454,7 +611,6 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         column: InfiniteTableComputedColumn<T>;
         columnSortInfo: DataSourceSingleSortInfo<T> | null | undefined;
     }
-    export type InfiniteTableColumnPinned = 'start' | 'end' | false;
     export type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupBy, }: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
     export type InfiniteTableColumnRenderValueFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE>;
     export type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderRenderParams<T>) => Renderable;
@@ -527,7 +683,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         groupByField: string | string[];
         id?: string;
     };
-    export type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & Partial<InfiniteTablePivotFinalColumn<T, any>>;
+    export type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & Partial<InfiniteTablePivotFinalColumnVariant<T, any>>;
     export type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
         pivotBy: DataSourcePivotBy<DataType>[];
         pivotTotalColumnGroup?: true;
@@ -543,10 +699,11 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         pivotAggregator: AggregationReducer<DataType, any>;
         pivotAggregatorIndex: number;
         pivotGroupKeys: KeyType[];
-        pivotByAtIndex: PivotBy<DataType, KeyType>;
+        pivotByAtIndex?: PivotBy<DataType, KeyType>;
         pivotIndex: number;
         pivotGroupKey: KeyType;
     };
+    export type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
     type InfiniteTableComputedColumnBase<T> = {
         computedWidth: number;
         computedOffset: number;
@@ -560,7 +717,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         computedSortIndex: number;
         computedVisibleIndex: number;
         computedMultiSort: boolean;
-        computedPinned: InfiniteTableColumnPinned;
+        computedPinned: InfiniteTableColumnPinnedValues;
         computedDraggable: boolean;
         computedFirstInCategory: boolean;
         computedLastInCategory: boolean;
@@ -574,13 +731,14 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
 }
 declare module "utils/groupAndPivot/getPivotColumnsAndColumnGroups" {
     import type { DataSourceAggregationReducer, DataSourcePivotBy } from "components/DataSource/index";
-    import type { InfiniteTablePropColumnGroups, InfiniteTablePropColumnsMap } from "components/InfiniteTable/index";
+    import type { InfiniteTablePropColumnsMap } from "components/InfiniteTable/index";
     import type { InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
+    import { InfiniteTablePropColumnGroupsMap } from "components/InfiniteTable/types/InfiniteTableProps";
     import type { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
-    import { DeepMap } from "utils/DeepMap";
+    import { DeepMap } from "utils/DeepMap/index";
     export type ComputedColumnsAndGroups<DataType> = {
         columns: InfiniteTablePropColumnsMap<DataType, InfiniteTablePivotColumn<DataType>>;
-        columnGroups: InfiniteTablePropColumnGroups;
+        columnGroups: InfiniteTablePropColumnGroupsMap;
     };
     export function getPivotColumnsAndColumnGroups<DataType, KeyType = any>({ deepMap, pivotBy, pivotTotalColumnPosition, reducers, showSeparatePivotColumnForSingleAggregation, }: {
         deepMap: DeepMap<KeyType, boolean>;
@@ -632,11 +790,12 @@ declare module "components/DataSource/GroupRowsState" {
     }
 }
 declare module "utils/groupAndPivot/index" {
-    import { DataSourceAggregationReducer } from "@infinite-table/infinite-react";
+    import { DataSourceAggregationReducer, DataSourceMappings, LazyGroupDataDeepMap } from "@infinite-table/infinite-react";
     import { GroupRowsState } from "components/DataSource/GroupRowsState";
-    import { InfiniteTableColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn, InfiniteTablePivotFinalColumnGroup } from "components/InfiniteTable/types/InfiniteTableColumn";
+    import { InfiniteTableColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumnGroup, InfiniteTablePivotFinalColumnVariant } from "components/InfiniteTable/types/InfiniteTableColumn";
     import { InfiniteTableColumnGroup, InfiniteTableGroupColumnBase } from "components/InfiniteTable/types/InfiniteTableProps";
-    import { DeepMap } from "utils/DeepMap";
+    import { DeepMap } from "utils/DeepMap/index";
+    export const LAZY_ROOT_KEY_FOR_GROUPS: string;
     export type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
         id: string;
     };
@@ -670,6 +829,7 @@ declare module "utils/groupAndPivot/index" {
         indexInAll: number;
         groupCount?: number;
         groupBy?: (keyof T)[];
+        rootGroupBy?: (keyof T)[];
         pivotValuesMap?: PivotValuesDeepMap<T, any>;
         reducerResults?: Record<string, AggregationReducerResult>;
     };
@@ -684,6 +844,7 @@ declare module "utils/groupAndPivot/index" {
         groupKeys?: any[];
         groupCount: number;
         groupBy: (keyof T)[];
+        rootGroupBy: (keyof T)[];
         pivotValuesMap?: PivotValuesDeepMap<T, any>;
     };
     export type GroupKeyType<T extends any = any> = T;
@@ -705,7 +866,7 @@ declare module "utils/groupAndPivot/index" {
     };
     export type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
         column?: InfiniteTableColumn<DataType> | (({ column, }: {
-            column: InfiniteTablePivotFinalColumn<DataType, KeyType>;
+            column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
         }) => Partial<InfiniteTablePivotColumn<DataType>>);
         columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
             columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
@@ -717,6 +878,9 @@ declare module "utils/groupAndPivot/index" {
         pivot?: PivotBy<DataType, KeyType>[];
         reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
     };
+    type LazyGroupParams = {
+        mappings?: DataSourceMappings;
+    };
     export type DataGroupResult<DataType, KeyType extends any> = {
         deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
         groupParams: GroupParams<DataType, KeyType>;
@@ -725,6 +889,7 @@ declare module "utils/groupAndPivot/index" {
         topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
         pivot?: PivotBy<DataType, KeyType>[];
     };
+    export function lazyGroup<DataType, KeyType extends string = string>(groupParams: GroupParams<DataType, KeyType> & LazyGroupParams, rootData: LazyGroupDataDeepMap<DataType>): DataGroupResult<DataType, KeyType>;
     export function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
     export function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
     export type EnhancedFlattenParam<DataType, KeyType = any> = {
@@ -923,12 +1088,15 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
     import { DataSourceGroupBy, DataSourcePropGroupBy, DataSourcePropPivotBy, DataSourceState } from "components/DataSource/index";
     import { Renderable } from "components/types/Renderable";
     import { LoadMaskProps } from "components/InfiniteTable/components/LoadMask";
-    import type { InfiniteTableBaseColumn, InfiniteTableColumn, InfiniteTableColumnPinned, InfiniteTableColumnRenderFunction, InfiniteTableComputedColumn, InfiniteTableComputedPivotFinalColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
+    import type { InfiniteTableColumn, InfiniteTableColumnRenderFunction, InfiniteTableComputedColumn, InfiniteTableComputedPivotFinalColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
     import { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
     export type InfiniteTablePropColumnOrderNormalized = string[];
     export type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
-    export type InfiniteTablePropColumnVisibility = Map<string, false>;
-    export type InfiniteTablePropColumnPinning = Map<string, true | 'start' | 'end'>;
+    export type InfiniteTablePropColumnVisibility = Record<string, false>;
+    export type InfiniteTablePropColumnPinningMap = Map<string, true | 'start' | 'end'>;
+    export type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
+    export type InfiniteTablePropColumnPinningRecord = Record<string, true | 'start' | 'end'>;
+    export type InfiniteTablePropColumnPinning = InfiniteTablePropColumnPinningRecord | InfiniteTablePropColumnPinningMap;
     export type InfiniteTableRowStyleFnParams<T> = {
         rowIndex: number;
         groupBy?: (keyof T)[];
@@ -952,6 +1120,7 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         maxWidth?: number;
         defaultWidth?: number;
         defaultFlex?: number;
+        defaultPinned?: InfiniteTableColumnPinnedValues;
         header?: InfiniteTableColumn<T>['header'];
         comparer?: InfiniteTableColumn<T>['comparer'];
         draggable?: InfiniteTableColumn<T>['draggable'];
@@ -959,7 +1128,6 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         resizable?: InfiniteTableColumn<T>['resizable'];
         align?: InfiniteTableColumn<T>['align'];
         verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
-        defaultPinned?: InfiniteTableColumnPinned;
         renderValue?: InfiniteTableColumn<T>['renderValue'];
         render?: InfiniteTableColumn<T>['render'];
         valueGetter?: InfiniteTableColumn<T>['valueGetter'];
@@ -990,11 +1158,14 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
     export type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = InfiniteTablePropColumnsMap<T, ColumnType> | Record<string, ColumnType>;
     export type InfiniteTableColumns<T> = InfiniteTablePropColumns<T>;
     export type InfiniteTableColumnsMap<T> = InfiniteTablePropColumnsMap<T>;
-    export type InfiniteTablePropColumnGroups = Map<string, InfiniteTableColumnGroup>;
+    export type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
+    export type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
+    export type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
     /**
      * the keys is an array of strings: first string in the array is the column group id, next strings are the ids of all columns in the group
      * the value is the id of the column to leave as visible
      */
+    export type InfiniteTablePropCollapsedColumnGroupsMap = Map<string[], string>;
     export type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
     export type InfiniteTableColumnGroupHeaderRenderParams = {
         columnGroup: InfiniteTableComputedColumnGroup;
@@ -1025,7 +1196,7 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         pivotBy: DataSourcePropPivotBy<T>;
     };
     export type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
-    export type InfiniteTableGroupColumnBase<T> = InfiniteTableBaseColumn<T> & {
+    export type InfiniteTableGroupColumnBase<T> = InfiniteTableColumn<T> & {
         renderValue?: InfiniteTableColumnRenderFunction<T>;
         id?: string;
     };
@@ -1033,12 +1204,17 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
     };
     export type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
-    export type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => InfiniteTableGroupColumnBase<T>;
+    export type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
     export type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
     export type InfiniteTablePropPivotRowLabelsColumn<T> = InfiniteTablePropPivotColumn<T>;
     export type InfiniteTablePropComponents = {
         LoadMask?: React.FC<LoadMaskProps>;
     };
+    export type ScrollStopInfo = {
+        scrollTop: number;
+        firstVisibleRowIndex: number;
+        lastVisibleRowIndex: number;
+    };
     export interface InfiniteTableProps<T> {
         columns: InfiniteTablePropColumns<T>;
         pivotColumns?: InfiniteTablePropColumnsMap<T, InfiniteTablePivotColumn<T>>;
@@ -1095,6 +1271,8 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         onBlurWithin?: (event: React.FocusEvent<HTMLDivElement>) => void;
         onScrollToTop?: () => void;
         onScrollToBottom?: () => void;
+        scrollStopDelay?: number;
+        onScrollStop?: (param: ScrollStopInfo) => void;
         scrollToBottomOffset?: number;
         defaultColumnOrder?: InfiniteTablePropColumnOrder;
         columnOrder?: InfiniteTablePropColumnOrder;
@@ -1110,16 +1288,6 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         horizontal: boolean;
     };
 }
-declare module "components/types/Size" {
-    export interface Size {
-        width: number;
-        height: number;
-    }
-    export type OnResizeFn = (size: {
-        width: number;
-        height: number;
-    }) => void;
-}
 declare module "components/VirtualBrain/ScrollListener" {
     import { OnScrollFn, ScrollPosition } from "components/types/ScrollPosition";
     export class ScrollListener {
@@ -1134,7 +1302,7 @@ declare module "components/VirtualBrain/ScrollListener" {
 }
 declare module "components/InfiniteTable/types/InfiniteTableState" {
     import type { ScrollPosition } from "components/types/ScrollPosition";
-    import type { InfiniteTableColumnGroup, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnsMap, InfiniteTablePropColumnTypesMap, InfiniteTableProps } from "components/InfiniteTable/types/InfiniteTableProps";
+    import type { InfiniteTableColumnGroup, InfiniteTablePropColumnGroupsMap, InfiniteTablePropColumnPinningMap, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnsMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility, InfiniteTableProps } from "components/InfiniteTable/types/InfiniteTableProps";
     import { Size } from "components/types/Size";
     import { MutableRefObject } from 'react';
     import { SubscriptionCallback } from "components/types/SubscriptionCallback";
@@ -1148,6 +1316,7 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         groupIndex: number;
     }>;
     export interface InfiniteTableSetupState<T> {
+        propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
         columnsWhenInlineGroupRenderStrategy?: Map<string, InfiniteTableColumn<T>>;
         domRef: MutableRefObject<HTMLDivElement | null>;
         scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
@@ -1184,8 +1353,10 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
         onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
         onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
+        scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
         onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
         onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
+        onScrollStop: InfiniteTableProps<T>['onScrollStop'];
         scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
         focusedClassName: InfiniteTableProps<T>['focusedClassName'];
         focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
@@ -1200,7 +1371,7 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
         pivotColumn: InfiniteTableProps<T>['pivotColumn'];
         pivotRowLabelsColumn: InfiniteTableProps<T>['pivotRowLabelsColumn'];
-        pivotColumnGroups: InfiniteTableProps<T>['pivotColumnGroups'];
+        pivotColumnGroups: InfiniteTablePropColumnGroupsMap;
         activeIndex: NonUndefined<InfiniteTableProps<T>['activeIndex']>;
         columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
         columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
@@ -1216,11 +1387,11 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         rowHeight: number;
         headerHeight: number;
         licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
-        columnVisibility: NonUndefined<InfiniteTableProps<T>['columnVisibility']>;
-        columnPinning: NonUndefined<InfiniteTableProps<T>['columnPinning']>;
+        columnVisibility: InfiniteTablePropColumnVisibility;
+        columnPinning: InfiniteTablePropColumnPinningMap;
         columnSizing: InfiniteTablePropColumnSizingMap;
         columnTypes: InfiniteTablePropColumnTypesMap<T>;
-        columnGroups: NonUndefined<InfiniteTableProps<T>['columnGroups']>;
+        columnGroups: InfiniteTablePropColumnGroupsMap;
         collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
         pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
     }
@@ -1231,7 +1402,7 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
         columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
         columnGroupsMaxDepth: number;
-        computedColumnGroups: InfiniteTablePropColumnGroups;
+        computedColumnGroups: InfiniteTablePropColumnGroupsMap;
         rowHeightCSSVar: string;
         headerHeightCSSVar: string;
     }
@@ -1299,24 +1470,24 @@ declare module "components/InfiniteTable/types/index" {
     import type { InfiniteTableState } from "components/InfiniteTable/types/InfiniteTableState";
     import type { InfiniteTableAction } from "components/InfiniteTable/types/InfiniteTableAction";
     import type { InfiniteTableActionType } from "components/InfiniteTable/types/InfiniteTableActionType";
-    import type { InfiniteTableProps, InfiniteTableImperativeApi, InfiniteTablePropColumnOrder, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnAggregator, InfiniteTableColumnGroup, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropRowStyle, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTablePropRowClassName, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableColumnSizingOptions, Scrollbars } from "components/InfiniteTable/types/InfiniteTableProps";
+    import type { InfiniteTableProps, InfiniteTableImperativeApi, InfiniteTablePropColumnOrder, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnAggregator, InfiniteTableColumnGroup, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropRowStyle, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTablePropRowClassName, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableColumnSizingOptions, Scrollbars, InfiniteTableGroupColumnBase } from "components/InfiniteTable/types/InfiniteTableProps";
     import type { InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam } from "components/InfiniteTable/types/InfiniteTableColumn";
     import type { InfiniteTableComputedValues } from "components/InfiniteTable/types/InfiniteTableComputedValues";
     import type { InfiniteTableContextValue } from "components/InfiniteTable/types/InfiniteTableContextValue";
     import type { InfiniteTableRowInfo } from "utils/groupAndPivot/index";
-    export type { Scrollbars, InfiniteTableColumnAggregator, InfiniteTableComputedValues, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTableRowInfo, InfiniteTableGroupColumnFunction, InfiniteTablePropColumnOrder, InfiniteTablePropComponents, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnGroup, InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableContextValue, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizing, InfiniteTablePropColumnSizingMap, InfiniteTableColumnSizingOptions, InfiniteTableState, InfiniteTableAction, InfiniteTableProps, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableImperativeApi, InfiniteTableActionType, InfiniteTablePropRowStyle, InfiniteTablePropRowClassName, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTableGroupColumnGetterOptions, };
+    export type { Scrollbars, InfiniteTableColumnAggregator, InfiniteTableComputedValues, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTableRowInfo, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnBase, InfiniteTablePropColumnOrder, InfiniteTablePropComponents, InfiniteTablePropColumnVisibility as InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnGroup, InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableContextValue, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizing, InfiniteTablePropColumnSizingMap, InfiniteTableColumnSizingOptions, InfiniteTableState, InfiniteTableAction, InfiniteTableProps, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableImperativeApi, InfiniteTableActionType, InfiniteTablePropRowStyle, InfiniteTablePropRowClassName, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTableGroupColumnGetterOptions, };
 }
 declare module "components/InfiniteTable/InfiniteTableContext" {
     import { InfiniteTableContextValue } from "components/InfiniteTable/types/InfiniteTableContextValue";
     export function getInfiniteTableContext<T>(): React.Context<InfiniteTableContextValue<T>>;
 }
 declare module "components/InfiniteTable/utils/toMap" {
-    export function toMap<K extends string, V>(mapOrObject?: Map<K, V> | Record<K, V>): Map<K, V>;
+    export function toMap<K extends string, V>(mapOrObject?: Map<K, V> | Record<K, V>, weakMapCache?: WeakMap<any, any>): Map<K, V>;
 }
 declare module "components/InfiniteTable/state/computeColumnGroupsDepths" {
-    import type { InfiniteTablePropColumnGroups } from "components/InfiniteTable/types/InfiniteTableProps";
+    import type { InfiniteTablePropColumnGroupsMap } from "components/InfiniteTable/types/InfiniteTableProps";
     import type { InfiniteTableColumnGroupsDepthsMap } from "components/InfiniteTable/types/InfiniteTableState";
-    export function computeColumnGroupsDepths(columnGroups: InfiniteTablePropColumnGroups): InfiniteTableColumnGroupsDepthsMap;
+    export function computeColumnGroupsDepths(columnGroups: InfiniteTablePropColumnGroupsMap): InfiniteTableColumnGroupsDepthsMap;
 }
 declare module "components/InfiniteTable/state/getInitialState" {
     import { DataSourceState } from "components/DataSource/index";
@@ -1329,59 +1500,61 @@ declare module "components/InfiniteTable/state/getInitialState" {
      * be affected by props
      */
     export function initSetupState<T>(): InfiniteTableSetupState<T>;
-    export const forwardProps: <T>() => Partial<{
+    export const forwardProps: <T>(setupState: InfiniteTableSetupState<T>) => Partial<{
         columns: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumns<T, import("components/InfiniteTable/types").InfiniteTableColumn<T>>) => import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types").InfiniteTableColumn<T>>);
         header: 1 | ((value: boolean | undefined) => boolean);
         showSeparatePivotColumnForSingleAggregation: 1 | ((value: boolean | undefined) => boolean);
         pivotTotalColumnPosition: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableState").InfiniteTablePropPivotTotalColumnPosition | undefined) => import("components/InfiniteTable/types/InfiniteTableState").InfiniteTablePropPivotTotalColumnPosition);
         pivotColumns: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotColumn<T>> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotColumn<T>> | undefined);
-        pivotColumnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined);
+        pivotColumnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropColumnGroupsMap);
         sortable: 1 | ((value: boolean | undefined) => boolean);
         pivotColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T, import("components/InfiniteTable/types").InfiniteTableColumn<T> & import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotFinalColumn<T, any>> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T, import("components/InfiniteTable/types").InfiniteTableColumn<T> & import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotFinalColumn<T, any>> | undefined);
         components: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropComponents | undefined) => import("components/InfiniteTable/types").InfiniteTablePropComponents | undefined);
-        scrollTopId: 1 | ((value: string | number | undefined) => string | number | undefined);
+        loadingText: 1 | ((value: import("react").ReactNode) => import("react").ReactNode);
         viewportReservedWidth: 1 | ((value: number | undefined) => number | undefined);
+        pivotRowLabelsColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined);
         groupColumn: 1 | ((value: Partial<InfiniteTablePropGroupColumn<T>> | undefined) => Partial<InfiniteTablePropGroupColumn<T>> | undefined);
+        hideEmptyGroupColumns: 1 | ((value: boolean | undefined) => boolean);
+        columnVisibility: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility);
+        pinnedStartMaxWidth: 1 | ((value: number | undefined) => number | undefined);
+        pinnedEndMaxWidth: 1 | ((value: number | undefined) => number | undefined);
+        columnPinning: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnPinning | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropColumnPinningMap);
+        columnSizing: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnSizing | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnSizingMap);
+        columnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropColumnGroupsMap);
+        collapsedColumnGroups: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups);
         onScrollbarsChange: 1 | ((value: ((scrollbars: import("components/InfiniteTable/types").Scrollbars) => void) | undefined) => ((scrollbars: import("components/InfiniteTable/types").Scrollbars) => void) | undefined);
-        loadingText: 1 | ((value: import("react").ReactNode) => import("react").ReactNode);
-        onReady: 1 | ((value: ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined) => ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined);
+        columnTypes: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnTypes<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnTypesMap<T>);
+        rowHeight: 1 | ((value: string | number) => number);
+        rowStyle: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined);
+        rowClassName: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined);
+        headerHeight: 1 | ((value: string | number) => number);
+        domProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | undefined) => import("react").HTMLProps<HTMLDivElement> | undefined);
+        showZebraRows: 1 | ((value: boolean | undefined) => boolean);
+        showHoverRows: 1 | ((value: boolean | undefined) => boolean);
+        draggableColumns: 1 | ((value: boolean | undefined) => boolean);
+        focusedClassName: 1 | ((value: string | undefined) => string | undefined);
+        focusedWithinClassName: 1 | ((value: string | undefined) => string | undefined);
+        focusedStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
+        focusedWithinStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
+        columnDefaultWidth: 1 | ((value: number | undefined) => number);
+        columnMinWidth: 1 | ((value: number | undefined) => number);
+        columnMaxWidth: 1 | ((value: number | undefined) => number);
+        virtualizeColumns: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T>);
+        activeIndex: 1 | ((value: number | undefined) => number);
         onSelfFocus: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
         onSelfBlur: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
         onFocusWithin: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
         onBlurWithin: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
         onScrollToTop: 1 | ((value: (() => void) | undefined) => (() => void) | undefined);
         onScrollToBottom: 1 | ((value: (() => void) | undefined) => (() => void) | undefined);
+        scrollStopDelay: 1 | ((value: number | undefined) => number);
+        onScrollStop: 1 | ((value: ((param: import("components/InfiniteTable/types/InfiniteTableProps").ScrollStopInfo) => void) | undefined) => ((param: import("components/InfiniteTable/types/InfiniteTableProps").ScrollStopInfo) => void) | undefined);
         scrollToBottomOffset: 1 | ((value: number | undefined) => number | undefined);
-        focusedClassName: 1 | ((value: string | undefined) => string | undefined);
-        focusedWithinClassName: 1 | ((value: string | undefined) => string | undefined);
-        focusedStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
-        focusedWithinStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
-        domProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | undefined) => import("react").HTMLProps<HTMLDivElement> | undefined);
-        rowStyle: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined);
-        rowProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined) => import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined);
-        rowClassName: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined);
-        pinnedStartMaxWidth: 1 | ((value: number | undefined) => number | undefined);
-        pinnedEndMaxWidth: 1 | ((value: number | undefined) => number | undefined);
-        pivotRowLabelsColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined);
-        activeIndex: 1 | ((value: number | undefined) => number);
-        columnMinWidth: 1 | ((value: number | undefined) => number);
-        columnMaxWidth: 1 | ((value: number | undefined) => number);
-        columnDefaultWidth: 1 | ((value: number | undefined) => number);
-        draggableColumns: 1 | ((value: boolean | undefined) => boolean);
-        hideEmptyGroupColumns: 1 | ((value: boolean | undefined) => boolean);
         columnOrder: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnOrder | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnOrder);
-        showZebraRows: 1 | ((value: boolean | undefined) => boolean);
-        showHoverRows: 1 | ((value: boolean | undefined) => boolean);
-        virtualizeColumns: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T>);
+        onReady: 1 | ((value: ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined) => ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined);
+        rowProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined) => import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined);
         licenseKey: 1 | ((value: string | undefined) => string);
-        columnVisibility: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility);
-        columnPinning: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnPinning | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnPinning);
-        columnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnGroups);
-        collapsedColumnGroups: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups);
-        columnSizing: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnSizing | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnSizingMap);
-        columnTypes: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnTypes<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnTypesMap<T>);
-        rowHeight: 1 | ((value: string | number) => number);
-        headerHeight: 1 | ((value: string | number) => number);
+        scrollTopId: 1 | ((value: string | number | undefined) => string | number | undefined);
     }>;
     export const mapPropsToState: <T>(params: {
         props: InfiniteTableProps<T>;
@@ -1458,12 +1631,8 @@ declare module "components/flexbox/index" {
     export const computeFlex: (params: FlexComputeParams) => FlexComputeResult;
 }
 declare module "components/InfiniteTable/utils/adjustColumnOrderForPinning" {
-    import { InfiniteTablePropColumnPinning } from "components/InfiniteTable/types/index";
-    import { InfiniteTablePropColumnOrderNormalized } from "components/InfiniteTable/types/InfiniteTableProps";
-    export const adjustColumnOrderForPinning: (columnOrder: InfiniteTablePropColumnOrderNormalized, columnPinning: InfiniteTablePropColumnPinning) => InfiniteTablePropColumnOrderNormalized;
-}
-declare module "utils/getGlobal" {
-    export function getGlobal<T extends Window>(): T;
+    import { InfiniteTablePropColumnOrderNormalized, InfiniteTablePropColumnPinningMap } from "components/InfiniteTable/types/InfiniteTableProps";
+    export const adjustColumnOrderForPinning: (columnOrder: InfiniteTablePropColumnOrderNormalized, columnPinning: InfiniteTablePropColumnPinningMap) => InfiniteTablePropColumnOrderNormalized;
 }
 declare module "components/utils/getScrollbarWidth" {
     export function getScrollbarWidth(): number;
@@ -1477,7 +1646,7 @@ declare module "components/InfiniteTable/utils/getComputedVisibleColumns" {
     import type { InfiniteTableColumn, InfiniteTableComputedColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
     import type { Size } from "components/types/Size";
     import type { DataSourceSingleSortInfo } from "components/DataSource/types";
-    import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnOrderNormalized, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
+    import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnOrderNormalized, InfiniteTablePropColumnPinningMap, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
     export type SortInfoMap<T> = {
         [key: string]: {
             sortInfo: DataSourceSingleSortInfo<T>;
@@ -1519,7 +1688,7 @@ declare module "components/InfiniteTable/utils/getComputedVisibleColumns" {
         setSortInfo: (sortInfo: DataSourceSingleSortInfo<T>[]) => void;
         draggableColumns?: boolean;
         columnOrder: InfiniteTablePropColumnOrder;
-        columnPinning: InfiniteTablePropColumnPinning;
+        columnPinning: InfiniteTablePropColumnPinningMap;
         columnSizing: InfiniteTablePropColumnSizingMap;
         columnTypes: InfiniteTablePropColumnTypesMap<T>;
         columnVisibility: InfiniteTablePropColumnVisibility;
@@ -1555,7 +1724,7 @@ declare module "components/InfiniteTable/hooks/useRerenderOnKeyChange" {
 declare module "components/InfiniteTable/hooks/useComputedVisibleColumns" {
     import type { DataSourceSingleSortInfo } from "components/DataSource/types";
     import type { InfiniteTableColumn } from "components/InfiniteTable/types/index";
-    import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
+    import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinningMap, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
     import type { Size } from "components/types/Size";
     import type { GetComputedVisibleColumnsResult } from "components/InfiniteTable/utils/getComputedVisibleColumns";
     type UseComputedVisibleColumnsParam<T> = {
@@ -1572,7 +1741,7 @@ declare module "components/InfiniteTable/hooks/useComputedVisibleColumns" {
         multiSort: boolean;
         sortInfo?: DataSourceSingleSortInfo<T>[];
         setSortInfo: (sortInfo: DataSourceSingleSortInfo<T>[]) => void;
-        columnPinning: InfiniteTablePropColumnPinning;
+        columnPinning: InfiniteTablePropColumnPinningMap;
         columnSizing: InfiniteTablePropColumnSizingMap;
         columnTypes: InfiniteTablePropColumnTypesMap<T>;
         columnOrder: InfiniteTablePropColumnOrder;
@@ -1684,8 +1853,8 @@ declare module "components/InfiniteTable/utils/getColumnForGroupBy" {
     export function getColumnForGroupBy<T>(options: InfiniteTableGroupColumnGetterOptions<T> & {
         groupIndexForColumn: number;
         groupByForColumn: DataSourceGroupBy<T>;
-    }, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: InfiniteTablePropGroupColumn<T>): InfiniteTableGeneratedGroupColumn<T>;
-    export function getSingleGroupColumn<T>(options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: InfiniteTablePropGroupColumn<T>): InfiniteTableGeneratedGroupColumn<T>;
+    }, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: Partial<InfiniteTablePropGroupColumn<T>>): InfiniteTableGeneratedGroupColumn<T>;
+    export function getSingleGroupColumn<T>(options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: Partial<InfiniteTablePropGroupColumn<T>>): InfiniteTableGeneratedGroupColumn<T>;
 }
 declare module "components/InfiniteTable/hooks/useToggleGroupRow" {
     export type ToggleGrouRowFn = (groupKeys: any[]) => void;
@@ -1724,93 +1893,6 @@ declare module "components/InfiniteTable/components/InfiniteTableBody/InfiniteTa
 declare module "components/InfiniteTable/components/InfiniteTableBody/index" {
     export * from "components/InfiniteTable/components/InfiniteTableBody/InfiniteTableBody";
 }
-declare module "components/VirtualBrain/index" {
-    import { Logger } from "utils/debug";
-    import { Size } from "components/types/Size";
-    import type { OnScrollFn, ScrollPosition } from "components/types/ScrollPosition";
-    type MainAxisOptions = 'vertical' | 'horizontal';
-    export type VirtualBrainOptions = {
-        mainAxis: MainAxisOptions;
-        itemSize: MainAxisSize;
-        itemSpan?: ({ itemIndex }: {
-            itemIndex: number;
-        }) => number;
-        count: number;
-        name?: string;
-    };
-    export type MainAxisSize = number | ((itemIndex: number) => number);
-    type OnRenderCountChangeFn = (renderCount: number) => void;
-    type OnSizeChangeFn = (size: number) => void;
-    type OnDestroyFn = () => void;
-    export type GetItemPositionFn = (itemIndex: number) => number;
-    export type RenderRange = {
-        renderStartIndex: number;
-        renderEndIndex: number;
-    };
-    export type OnRenderRangeChangeFn = (renderRange: RenderRange) => void;
-    export class VirtualBrain extends Logger {
-        private scrollPosition;
-        private scrollPositionOnMainAxis;
-        private itemSpanParent;
-        private itemSpanValue;
-        private itemSizeCache;
-        private itemOffsetCache;
-        private options;
-        private destroyed;
-        private totalSize;
-        private onScrollFns;
-        private onTotalSizeChangeFns;
-        private onRenderCountChangeFns;
-        private onRenderRangeChangeFns;
-        private onDestroyFns;
-        name: string | undefined;
-        private renderCount;
-        private renderRange;
-        private availableSize;
-        constructor(options: VirtualBrainOptions);
-        setAvailableSize: (size: Size) => void;
-        getOptions(): VirtualBrainOptions;
-        private updateRenderCount;
-        private computeRenderCount;
-        private setRenderCount;
-        private updateRenderRange;
-        getRenderStartIndex(): number;
-        getRenderCount: () => number;
-        setScrollPosition: (scrollPosition: ScrollPosition) => void;
-        private notifyScrollChange;
-        private notifyDestroy;
-        private notifyTotalSizeChange;
-        private notifyRenderCountChange;
-        private notifyRenderRangeChange;
-        getRenderRange: () => RenderRange;
-        private setRenderRange;
-        private computeRenderRange;
-        getScrollPosition: () => ScrollPosition;
-        onScroll: (fn: OnScrollFn) => () => void;
-        onTotalSizeChange: (fn: OnSizeChangeFn) => () => void;
-        onRenderCountChange: (fn: OnRenderCountChangeFn) => () => void;
-        onRenderRangeChange: (fn: OnRenderRangeChangeFn) => () => void;
-        onDestroy: (fn: OnDestroyFn) => () => void;
-        update: (newCount: VirtualBrainOptions['count'], newItemSize: VirtualBrainOptions['itemSize'], newItemSpan?: VirtualBrainOptions['itemSpan']) => void;
-        private reset;
-        private computeItemSpanUpTo;
-        private computeCacheFor;
-        private getItemSizeCacheFor;
-        getItemSpan: (itemIndex: number) => number;
-        getItemSpanParent: (itemIndex: number) => number;
-        getItemSizeWithSpan: (itemIndex: number, itemSpan: number) => number;
-        /**
-         * For now, this doesn't take into account the itemspan, and it's okay not to
-         * @param itemIndex
-         * @returns the size of the specified item
-         */
-        getItemSize: (itemIndex: number) => number;
-        getTotalSize: () => number;
-        getItemAt: (scrollPos: number) => number;
-        getItemOffsetFor: (itemIndex: number) => number;
-        destroy: () => void;
-    }
-}
 declare module "components/InfiniteTable/components/ScrollbarPlaceholder" {
     import * as React from 'react';
     function HorizontalScrollbarPlaceholderFn(props: {
@@ -1891,9 +1973,7 @@ declare module "components/InfiniteTable/components/cell.css" {
         unpinned: {};
         pinnedStartLastInCategory: {
             borderRight: import("@vanilla-extract/private").CSSVarFunction;
-            vars: {
-                [x: string]: import("@vanilla-extract/private").CSSVarFunction;
-            };
+            vars: {};
         };
         pinnedEndFirstInCategory: {
             borderLeft: import("@vanilla-extract/private").CSSVarFunction;
@@ -2115,15 +2195,14 @@ declare module "components/InfiniteTable/components/InfiniteTableHeader/Infinite
     import { Renderable } from "components/types/Renderable";
     import { VirtualBrain } from "components/VirtualBrain/index";
     import { ScrollListener } from "components/VirtualBrain/ScrollListener";
-    import { InfiniteTableColumnPinned } from "components/InfiniteTable/types/InfiniteTableColumn";
-    import { InfiniteTableComputedColumnGroup } from "components/InfiniteTable/types/InfiniteTableProps";
+    import { InfiniteTableColumnPinnedValues, InfiniteTableComputedColumnGroup } from "components/InfiniteTable/types/InfiniteTableProps";
     export type InfiniteTableHeaderProps<T> = {
         repaintId?: string | number;
         brain: VirtualBrain;
         columns: InfiniteTableComputedColumn<T>[];
         totalWidth: number;
         availableWidth: number;
-        pinning: InfiniteTableColumnPinned;
+        pinning: InfiniteTableColumnPinnedValues;
     };
     export type InfiniteTableHeaderGroupProps<T> = {
         columns: InfiniteTableComputedColumn<T>[];
@@ -2630,6 +2709,9 @@ declare module "components/InfiniteTable/hooks/usePinnedRendering" {
         pinnedStartScrollbarPlaceholder: JSX.Element | null;
     };
 }
+declare module "components/hooks/useOnce" {
+    export function useOnce<ReturnType>(fn: () => ReturnType): ReturnType;
+}
 declare module "components/InfiniteTable/hooks/useColumnSizeFn" {
     import { InfiniteTableComputedColumn } from "components/InfiniteTable/types/index";
     /**