@infinite-table/infinite-react 0.2.20 → 0.3.0-canary.0

package/index.d.ts

@@ -1,16 +1,12 @@
 import * as _vanilla_extract_private from '@vanilla-extract/private';
 import * as React$1 from 'react';
-import { CSSProperties, HTMLProps, MutableRefObject } from 'react';
+import { MutableRefObject, CSSProperties, HTMLProps } from 'react';
 
 declare function debounce(fn: Function, { wait }: {
     wait: number;
 }): (...args: any[]) => void;
 
-interface ScrollPosition {
-    scrollTop: number;
-    scrollLeft: number;
-}
-declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
+declare type Renderable = React$1.ReactNode | JSX.Element;
 
 declare type SortDir = 1 | -1;
 declare type MultisortInfo<T> = {
@@ -50,6 +46,7 @@ declare class DeepMap<KeyType, ValueType> {
     private emptyKey;
     static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
     constructor(initial?: [KeyType[], ValueType][]);
+    getValuesStartingWith(keys: KeyType[]): ValueType[];
     set(keys: KeyType[] & {
         length: Omit<number, 0>;
     }, value: ValueType): this;
@@ -72,22 +69,6 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
-declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
-    getComponentState: () => T_STATE;
-    componentState: T_STATE;
-    componentActions: T_ACTIONS;
-};
-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 ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
-
 declare class GroupRowsState<KeyType extends any = any> {
     private expandedMap?;
     private collapsedMap?;
@@ -110,7 +91,16 @@ declare class GroupRowsState<KeyType extends any = any> {
     toggleGroupRow(keys: KeyType[]): void;
 }
 
-declare type NonUndefined<T> = T extends undefined ? never : T;
+interface ScrollPosition {
+    scrollTop: number;
+    scrollLeft: number;
+}
+declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
+
+interface Size {
+    width: number;
+    height: number;
+}
 
 declare type VoidFn = () => void;
 
@@ -122,6 +112,34 @@ interface SubscriptionCallback<T> {
     onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
 }
 
+declare class ScrollListener {
+    private scrollPosition;
+    private onScrollFns;
+    getScrollPosition: () => ScrollPosition;
+    onScroll: (fn: OnScrollFn) => () => void;
+    setScrollPosition: (scrollPosition: ScrollPosition) => void;
+    private notifyScrollChange;
+    destroy: () => void;
+}
+
+declare type NonUndefined<T> = T extends undefined ? never : T;
+
+declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
+    getComponentState: () => T_STATE;
+    componentState: T_STATE;
+    componentActions: T_ACTIONS;
+};
+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 ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
+
 interface LogFn {
     (...args: any[]): LogFn;
     extend: (channelName: string) => LogFn;
@@ -132,170 +150,419 @@ declare class Logger {
     constructor(channelName: string);
 }
 
-interface Size {
+declare type FixedPosition = false | 'start' | 'end';
+declare type SpanFunction = ({ rowIndex, colIndex, }: {
+    rowIndex: number;
+    colIndex: number;
+}) => number;
+declare type RenderRangeType = {
+    startIndex: number;
+    endIndex: number;
+};
+declare type ItemSizeFunction = (index: number) => number;
+declare type MatrixBrainOptions = {
     width: number;
     height: number;
-}
-
-declare type MainAxisOptions = 'vertical' | 'horizontal';
-declare type VirtualBrainOptions = {
-    mainAxis: MainAxisOptions;
-    itemSize: MainAxisSize;
-    itemSpan?: ({ itemIndex }: {
-        itemIndex: number;
-    }) => number;
-    count: number;
-    name?: string;
+    cols: number;
+    rows: number;
+    rowHeight: number | ItemSizeFunction;
+    colWidth: number | ItemSizeFunction;
+    rowspan?: SpanFunction;
+    colspan?: SpanFunction;
 };
-declare type MainAxisSize = number | ((itemIndex: number) => number);
-declare type OnRenderCountChangeFn = (renderCount: number) => void;
-declare type OnSizeChangeFn = (size: number) => void;
-declare type OnDestroyFn = () => void;
-declare type RenderRange = {
-    renderStartIndex: number;
-    renderEndIndex: number;
+declare type TableRenderRange = {
+    start: [number, number];
+    end: [number, number];
+    rowFixed?: FixedPosition;
+    colFixed?: FixedPosition;
 };
-declare type OnRenderRangeChangeFn = (renderRange: RenderRange) => void;
-declare class VirtualBrain extends Logger {
+declare type WhichDirection = {
+    horizontal?: boolean;
+    vertical?: boolean;
+};
+declare type FnOnRenderRangeChange = (range: TableRenderRange) => void;
+declare type FnOnDirectionalRenderRangeChange = (range: [number, number]) => void;
+declare type FnOnRenderCountChange = ({ horizontal, vertical, }: {
+    horizontal: number;
+    vertical: number;
+}) => void;
+declare type OnAvailableSizeChange = (size: Size) => void;
+declare class MatrixBrain extends Logger {
+    private scrolling;
+    private width;
+    private height;
+    private cols;
+    private rows;
+    private rowHeight;
+    private colWidth;
+    private rowspan;
+    private colspan;
+    private rowspanParent;
+    private rowspanValue;
+    private rowHeightCache;
+    private rowOffsetCache;
+    private verticalTotalSize;
+    private colspanParent;
+    private colspanValue;
+    private colWidthCache;
+    private colOffsetCache;
+    private horizontalTotalSize;
+    private horizontalRenderCount?;
+    private verticalRenderCount?;
+    private horizontalRenderRange;
+    private verticalRenderRange;
+    private extraSpanCells;
     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 onVerticalRenderRangeChangeFns;
+    private onHorizontalRenderRangeChangeFns;
     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 destroyed;
+    private onRenderCountChangeFns;
+    private onAvailableSizeChangeFns;
+    private onScrollStartFns;
+    private onScrollStopFns;
+    private scrollTimeoutId;
+    private scrollStopDelay;
+    /**
+     * Number of columns that are fixed at the start
+     */
+    private fixedColsStart;
+    /**
+     * Number of columns that are fixed at the end
+     */
+    private fixedColsEnd;
+    /**
+     * Number of rows that are fixed at the start
+     */
+    private fixedRowsStart;
+    /**
+     * Number of rows that are fixed at the end
+     */
+    private fixedRowsEnd;
+    constructor();
+    private reset;
+    private resetVertical;
+    private resetHorizontal;
+    setScrollStopDelay: (scrollStopDelay: number) => void;
+    getRowCount: () => number;
+    getColCount: () => number;
+    update: (options: Partial<MatrixBrainOptions>) => void;
+    setRowAndColumnSizes({ rowHeight, colWidth, }: {
+        rowHeight: number | ItemSizeFunction;
+        colWidth: number | ItemSizeFunction;
+    }): void;
+    setRowsAndCols: ({ rows, cols }: {
+        rows: number;
+        cols: number;
+    }) => void;
+    setAvailableSize(size: Partial<Size>, config?: {
+        skipUpdateRenderCount?: boolean;
+    }): void;
+    updateRenderCount: (which?: WhichDirection) => void;
+    private doUpdateRenderCount;
+    get scrollTopMax(): number;
+    get scrollLeftMax(): number;
+    private setScrolling;
+    private notifyScrollStart;
+    private notifyScrollStop;
+    setScrollPosition: (scrollPosition: ScrollPosition, callback?: ((scrollPos: ScrollPosition) => void) | undefined) => void;
+    private notifyAvailableSizeChange;
+    private notifyRenderRangeChange;
+    private notifyVerticalRenderRangeChange;
+    private notifyHorizontalRenderRangeChange;
     private notifyScrollChange;
-    private notifyDestroy;
-    private notifyTotalSizeChange;
+    private computeDirectionalRenderCount;
+    getFixedSize(direction: 'horizontal' | 'vertical'): number;
+    getFixedStartSize(direction: 'horizontal' | 'vertical'): number;
+    getFixedEndSize(direction: 'horizontal' | 'vertical'): number;
+    getFixedEndColsWidth: () => number;
+    /**
+     * Returns an array of offsets for all cols fixed at the end
+     *
+     * The order in the array is from leftmost col to the rightmost col
+     * The reference for offset is the left side of the table.
+     * The offsets take into account the scroll position and return the correct position.
+     *
+     * The indexes in the returned array are the absolute indexes of the cols, so the returned array is an array with holes
+     *
+     */
+    getFixedEndColsOffsets: () => number[];
+    /**
+     * Returns an array of offsets for all rows fixed at the end
+     *
+     * The order in the array is from topmost row to the bottom-most row
+     * The reference for offset is the top side of the table.
+     * The offsets take into account the scroll position and return the correct position.
+     *
+     * The indexes in the returned array are the absolute indexes of the rows, so the returned array is an array with holes
+     *
+     */
+    getFixedEndRowsOffsets: () => number[];
+    getFixedStartColsWidth: () => number;
+    getFixedEndRowsHeight: () => number;
+    getFixedStartRowsHeight: () => number;
+    computeRenderCount: (which?: WhichDirection) => {
+        horizontal: number;
+        vertical: number;
+    };
+    setRenderCount: ({ horizontal, vertical, }: {
+        horizontal: number;
+        vertical: number;
+    }) => void;
     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;
+    updateFixedCells: (config: {
+        fixedColsStart?: number;
+        fixedColsEnd?: number;
+        fixedRowsStart?: number;
+        fixedRowsEnd?: number;
+    }) => void;
+    getFixedCellInfo: () => {
+        fixedRowsStart: number;
+        fixedColsStart: number;
+        fixedRowsEnd: number;
+        fixedColsEnd: number;
+    };
+    updateRenderRange: (which?: WhichDirection) => void;
+    getExtraSpanCellsForRange: ({ horizontal, vertical, }: {
+        horizontal: RenderRangeType;
+        vertical: RenderRangeType;
+    }) => [number, number][];
+    computeRenderRange: (which?: WhichDirection) => {
+        horizontal: RenderRangeType;
+        vertical: RenderRangeType;
+        extraCells: [number, number][];
+    };
+    computeDirectionalRenderRange: (direction: 'horizontal' | 'vertical') => {
+        startIndex: number;
+        endIndex: number;
+    };
+    getItemAt: (scrollPos: number, direction: 'horizontal' | 'vertical') => number;
+    getCellOffset: (rowIndex: number, colIndex: number) => {
+        x: number;
+        y: number;
+    };
+    private getItemOffsetFor;
     private computeCacheFor;
     private getItemSizeCacheFor;
-    getItemSpan: (itemIndex: number) => number;
-    getItemSpanParent: (itemIndex: number) => number;
-    getItemSizeWithSpan: (itemIndex: number, itemSpan: number) => number;
+    private computeItemSpanUpTo;
+    private getCellSpan;
+    getRowspan: (rowIndex: number, colIndex: number) => number;
+    getColspan: (rowIndex: number, colIndex: number) => number;
+    getRowspanParent: (rowIndex: number, colIndex: number) => number;
+    getColspanParent: (rowIndex: number, colIndex: number) => number;
+    getItemSpanParent: (rowIndex: number, colIndex: number, direction: 'horizontal' | 'vertical') => number;
+    getRowHeightWithSpan: (rowIndex: number, colIndex: number, rowspan: number) => number;
+    getColWidthWithSpan: (rowIndex: number, colIndex: number, colspan: number) => number;
+    private getItemSizeWithSpan;
+    getRowHeight: (rowIndex: number) => number;
+    getColWidth: (colIndex: number) => number;
     /**
-     * For now, this doesn't take into account the itemspan, and it's okay not to
+     * For now, this doesn't take into account the row/colspan, and it's okay not to
      * @param itemIndex
      * @returns the size of the specified item
      */
-    getItemSize: (itemIndex: number) => number;
-    getTotalSize: () => number;
-    getItemAt: (scrollPos: number) => number;
-    getItemOffsetFor: (itemIndex: number) => number;
+    getItemSize: (itemIndex: number, direction: 'horizontal' | 'vertical') => number;
+    getTotalSize: () => {
+        height: number;
+        width: number;
+    };
+    getTotalSizeFor: (direction: 'horizontal' | 'vertical') => number;
+    setRenderRange: ({ horizontal, vertical, extraCells, }: {
+        horizontal: RenderRangeType;
+        vertical: RenderRangeType;
+        extraCells?: [number, number][] | undefined;
+    }) => void;
+    getRenderRangeCellCount: (range: TableRenderRange) => number;
+    getExtraCells: () => [
+        number,
+        number
+    ][];
+    getScrollPosition: () => ScrollPosition;
+    getRenderRange: () => TableRenderRange;
+    onScroll: (fn: OnScrollFn) => () => void;
+    onScrollStart: (fn: VoidFunction) => () => void;
+    onScrollStop: (fn: (scrollPos: ScrollPosition) => void) => () => void;
+    onRenderRangeChange: (fn: FnOnRenderRangeChange) => () => void;
+    onVerticalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
+    onHorizontalRenderRangeChange: (fn: FnOnDirectionalRenderRangeChange) => () => void;
+    onRenderCountChange: (fn: FnOnRenderCountChange) => () => void;
+    onAvailableSizeChange: (fn: OnAvailableSizeChange) => () => void;
+    onDestroy: (fn: VoidFn) => () => void;
+    getAvailableSize: () => {
+        width: number;
+        height: number;
+    };
+    private notifyDestroy;
     destroy: () => void;
 }
 
-declare type Renderable = React$1.ReactNode | JSX.Element;
+interface InfiniteTableSetupState<T> {
+    propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
+    columnsWhenInlineGroupRenderStrategy?: Map<string, InfiniteTableColumn<T>>;
+    domRef: MutableRefObject<HTMLDivElement | null>;
+    scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
+    portalDOMRef: MutableRefObject<HTMLDivElement | null>;
+    onRowHeightCSSVarChange: SubscriptionCallback<number>;
+    onHeaderHeightCSSVarChange: SubscriptionCallback<number>;
+    columnsWhenGrouping?: InfiniteTablePropColumnsMap<T>;
+    bodySize: Size;
+    brain: MatrixBrain;
+    headerBrain: MatrixBrain;
+    focused: boolean;
+    ready: boolean;
+    focusedWithin: boolean;
+    scrollPosition: ScrollPosition;
+    draggingColumnId: null | string;
+    pinnedStartScrollListener: ScrollListener;
+    pinnedEndScrollListener: ScrollListener;
+    columnShifts: number[] | null;
+}
+declare type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
+declare type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
+declare type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
+interface InfiniteTableMappedState<T> {
+    scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
+    viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
+    groupColumn: InfiniteTableProps<T>['groupColumn'];
+    onScrollbarsChange: InfiniteTableProps<T>['onScrollbarsChange'];
+    loadingText: InfiniteTableProps<T>['loadingText'];
+    components: InfiniteTableProps<T>['components'];
+    columns: InfiniteTablePropColumnsMap<T>;
+    pivotColumns: InfiniteTableProps<T>['pivotColumns'];
+    onReady: InfiniteTableProps<T>['onReady'];
+    onSelfFocus: InfiniteTableProps<T>['onSelfFocus'];
+    onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
+    onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
+    onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
+    autoSizeColumnsKey: InfiniteTableProps<T>['autoSizeColumnsKey'];
+    scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
+    onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
+    onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
+    onScrollStop: InfiniteTableProps<T>['onScrollStop'];
+    scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
+    focusedClassName: InfiniteTableProps<T>['focusedClassName'];
+    focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
+    focusedStyle: InfiniteTableProps<T>['focusedStyle'];
+    focusedWithinStyle: InfiniteTableProps<T>['focusedWithinStyle'];
+    showSeparatePivotColumnForSingleAggregation: NonUndefined<InfiniteTableProps<T>['showSeparatePivotColumnForSingleAggregation']>;
+    domProps: InfiniteTableProps<T>['domProps'];
+    rowStyle: InfiniteTableProps<T>['rowStyle'];
+    rowProps: InfiniteTableProps<T>['rowProps'];
+    rowClassName: InfiniteTableProps<T>['rowClassName'];
+    pinnedStartMaxWidth: InfiniteTableProps<T>['pinnedStartMaxWidth'];
+    pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
+    pivotColumn: InfiniteTableProps<T>['pivotColumn'];
+    pivotColumnGroups: InfiniteTablePropColumnGroupsMap;
+    activeIndex: NonUndefined<InfiniteTableProps<T>['activeIndex']>;
+    columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
+    columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
+    columnDefaultWidth: NonUndefined<InfiniteTableProps<T>['columnDefaultWidth']>;
+    columnCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnCssEllipsis']>;
+    draggableColumns: NonUndefined<InfiniteTableProps<T>['draggableColumns']>;
+    sortable: NonUndefined<InfiniteTableProps<T>['sortable']>;
+    hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
+    columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
+    showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
+    showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
+    header: NonUndefined<InfiniteTableProps<T>['header']>;
+    virtualizeColumns: NonUndefined<InfiniteTableProps<T>['virtualizeColumns']>;
+    rowHeight: number;
+    headerHeight: number;
+    licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
+    columnVisibility: InfiniteTablePropColumnVisibility;
+    columnPinning: InfiniteTablePropColumnPinningMap;
+    columnSizing: InfiniteTablePropColumnSizing;
+    columnTypes: InfiniteTablePropColumnTypes<T>;
+    columnGroups: InfiniteTablePropColumnGroupsMap;
+    collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
+    pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
+    pivotGrandTotalColumnPosition: InfiniteTableProps<T>['pivotGrandTotalColumnPosition'];
+}
+interface InfiniteTableDerivedState<T> {
+    groupBy: DataSourceProps<T>['groupBy'];
+    computedColumns: Map<string, InfiniteTableColumn<T>>;
+    groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
+    columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
+    columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
+    columnGroupsMaxDepth: number;
+    computedColumnGroups: InfiniteTablePropColumnGroupsMap;
+    rowHeightCSSVar: string;
+    headerHeightCSSVar: string;
+    controlledColumnVisibility: boolean;
+}
+declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
+interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
+}
 
-declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-}[Keys];
+declare enum InfiniteTableActionType {
+    SET_COLUMN_SIZE = 0,
+    SET_SCROLL_POSITION = 1,
+    SET_BODY_SIZE = 2,
+    SET_COLUMN_ORDER = 3,
+    SET_COLUMN_VISIBILITY = 4,
+    SET_COLUMN_SHIFTS = 5,
+    SET_COLUMN_PINNING = 6,
+    SET_COLUMN_AGGREGATIONS = 7,
+    SET_DRAGGING_COLUMN_ID = 8
+}
 
-declare type InfiniteTableCellProps<T> = {
-    column: InfiniteTableComputedColumn<T>;
-    renderChildren: () => Renderable;
-    cssEllipsis?: boolean;
-    virtualized?: boolean;
-    skipColumnShifting?: boolean;
-    beforeChildren?: Renderable;
-    afterChildren?: Renderable;
-    offset?: number;
-    offsetProperty?: 'left' | 'right';
-    cssPosition?: CSSProperties['position'];
-    domRef?: React.RefCallback<HTMLElement>;
-    cellType: 'body' | 'header';
+declare type InfiniteTableAction = {
+    type: InfiniteTableActionType;
+    payload?: any;
 };
 
-declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
-declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    sortTool: JSX.Element;
-    column: COL_TYPE;
-    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
-};
-declare type InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    value: string | number | Renderable;
-    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
-    rowIndex: number;
-    column: COL_TYPE;
-    toggleCurrentGroupRow: () => void;
-    toggleGroupRow: InfiniteTableToggleGroupRowFn;
-    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
-    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
-} & ({
-    rowInfo: InfiniteTableRowInfoNormal<DATA_TYPE>;
-    data: DATA_TYPE;
-} | {
-    rowInfo: InfiniteTableRowInfoGroup<DATA_TYPE>;
-    data: Partial<DATA_TYPE> | null;
-});
-declare type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParams<DATA_TYPE> & {};
-declare type InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE> & {
-    collapsed: boolean;
-    groupIcon: Renderable;
+interface InfiniteTableComputedValues<T> {
+    scrollbars: {
+        vertical: boolean;
+        horizontal: boolean;
+    };
+    rowspan?: MatrixBrainOptions['rowspan'];
+    computedPinnedStartOverflow: boolean;
+    computedPinnedEndOverflow: boolean;
+    computedPinnedStartColumns: InfiniteTableComputedColumn<T>[];
+    computedPinnedEndColumns: InfiniteTableComputedColumn<T>[];
+    computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
+    computedVisibleColumns: InfiniteTableComputedColumn<T>[];
+    computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
+    computedColumnVisibility: InfiniteTablePropColumnVisibility;
+    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
+    computedPinnedStartColumnsWidth: number;
+    computedPinnedStartWidth: number;
+    computedPinnedEndColumnsWidth: number;
+    computedPinnedEndWidth: number;
+    computedUnpinnedColumnsWidth: number;
+    computedUnpinnedOffset: number;
+    computedPinnedEndOffset: number;
+    computedRemainingSpace: number;
+    toggleGroupRow: (groupKeys: any[]) => void;
+    columnSize: (colIndex: number) => number;
+}
+
+interface InfiniteTableContextValue<T> {
+    componentState: InfiniteTableState<T>;
+    componentActions: InfiniteTableActions<T>;
+    computed: InfiniteTableComputedValues<T>;
+    getComputed: () => InfiniteTableComputedValues<T>;
+    getState: () => InfiniteTableState<T>;
+}
+
+declare type LoadMaskProps = {
+    visible: boolean;
+    children: Renderable;
 };
-declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE>;
-declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
-    data: DATA_TYPE | Partial<DATA_TYPE> | null;
-    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
+
+declare type InfiniteTablePropColumnOrderNormalized = string[];
+declare type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
+declare type InfiniteTablePropColumnVisibility = Record<string, false>;
+declare type InfiniteTablePropColumnPinningMap = Map<string, true | 'start' | 'end'>;
+declare type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
+declare type InfiniteTablePropColumnPinningRecord = Record<string, true | 'start' | 'end'>;
+declare type InfiniteTablePropColumnPinning = InfiniteTablePropColumnPinningRecord | InfiniteTablePropColumnPinningMap;
+declare type InfiniteTableRowStyleFnParams<T> = {
     rowIndex: number;
-    column: COL_TYPE;
-};
-declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupBy, pivotBy, }: InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableGroupColumnRenderIconFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (param: InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderParams<T>) => Renderable;
-declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
-declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
-declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
-declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
-declare type InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T> = RequireAtLeastOne<{
-    /**
-     * Determines the field property of the column.
-     */
-    field?: keyof T;
-    render?: InfiniteTableColumnRenderFunction<T>;
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
-}, 'render' | 'renderValue' | 'field' | 'valueGetter'>;
-declare type InfiniteTableColumnStyleFnParams<T> = {
-    value: Renderable;
-    column: InfiniteTableColumn<T>;
+    groupBy?: (keyof T)[];
 } & ({
     data: T;
     rowInfo: InfiniteTableRowInfoNormal<T>;
@@ -303,127 +570,313 @@ declare type InfiniteTableColumnStyleFnParams<T> = {
     data: Partial<T> | null;
     rowInfo: InfiniteTableRowInfoGroup<T>;
 });
-declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
-declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
-declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
-declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
-declare type InfiniteTableColumnValueGetterParams<T> = {
-    data: T;
-    rowInfo: InfiniteTableRowInfoNormal<T>;
-} | {
-    data: Partial<T> | null;
-    rowInfo: InfiniteTableRowInfoGroup<T>;
+declare type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
+declare type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
+declare type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
+declare type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
+declare type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
+    getter?: AggregationReducer<T, AggregationResultType>['getter'];
+    field?: keyof T;
 };
-declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
-declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
-declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
-declare type InfiniteTableBaseColumn<T> = {
-    sortable?: boolean;
-    draggable?: boolean;
-    resizable?: boolean;
-    comparer?: InfiniteTableColumnComparer<T>;
-    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
-        [k in keyof Partial<T>]: true;
-    };
-    align?: InfiniteTableColumnAlign;
-    verticalAlign?: InfiniteTableColumnVerticalAlign;
-    columnGroup?: string;
-    header?: InfiniteTableColumnHeader<T>;
-    name?: Renderable;
-    cssEllipsis?: boolean;
-    headerCssEllipsis?: boolean;
-    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
-    style?: InfiniteTableColumnStyle<T>;
-    className?: InfiniteTableColumnClassName<T>;
-    rowspan?: InfiniteTableColumnRowspanFn<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
+declare type InfiniteTableColumnType<T> = {
+    minWidth?: number;
+    maxWidth?: number;
     defaultWidth?: number;
     defaultFlex?: number;
+    defaultPinned?: InfiniteTableColumnPinnedValues;
+    defaultHiddenWhenGroupedBy?: InfiniteTableColumn<T>['defaultHiddenWhenGroupedBy'];
+    header?: InfiniteTableColumn<T>['header'];
+    comparer?: InfiniteTableColumn<T>['comparer'];
+    draggable?: InfiniteTableColumn<T>['draggable'];
+    sortable?: InfiniteTableColumn<T>['sortable'];
+    resizable?: InfiniteTableColumn<T>['resizable'];
+    align?: InfiniteTableColumn<T>['align'];
+    verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
+    cssEllipsis?: boolean;
+    headerCssEllipsis?: boolean;
+    components?: InfiniteTableColumn<T>['components'];
+    renderValue?: InfiniteTableColumn<T>['renderValue'];
+    render?: InfiniteTableColumn<T>['render'];
+    valueGetter?: InfiniteTableColumn<T>['valueGetter'];
+    style?: InfiniteTableColumn<T>['style'];
+};
+declare type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
+declare type InfiniteTableColumnSizingOptions = {
+    flex?: number;
+    width?: number;
     minWidth?: number;
     maxWidth?: number;
-    components?: {
-        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
-        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
-    };
 };
-/**
- * Defines a column in the table.
- *
- * @typeParam DATA_TYPE The type of the data in the table.
- *
- * Can be bound to a field which is a `keyof DATA_TYPE`.
- */
-declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<DATA_TYPE>;
-declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
-    groupByField: string | string[];
-    id?: string;
+declare type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
+declare type InfiniteTableImperativeApi<T> = {
+    setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
+    setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
+    x?: T;
+    getState: () => InfiniteTableState<T>;
+    getDataSourceState: () => DataSourceState<T>;
 };
-declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
-declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotTotalColumnGroup?: true;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex: PivotBy<DataType, KeyType>;
-    pivotGroupKey: KeyType;
-    pivotIndex: number;
+declare type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
+declare type InfiniteTablePropColumnsMap<T, ColumnType = InfiniteTableColumn<T>> = Map<string, ColumnType>;
+declare type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = InfiniteTablePropColumnsMap<T, ColumnType> | Record<string, ColumnType>;
+declare type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
+declare type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
+declare type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
+declare type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
+declare type InfiniteTableColumnGroupHeaderRenderParams = {
+    columnGroup: InfiniteTableComputedColumnGroup;
 };
-declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotColumn: true;
-    pivotTotalColumn: boolean;
-    pivotAggregator: AggregationReducer<DataType, any>;
-    pivotAggregatorIndex: number;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex?: PivotBy<DataType, KeyType>;
-    pivotIndex: number;
-    pivotGroupKey: KeyType;
+declare type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
+declare type InfiniteTableColumnGroup = {
+    columnGroup?: string;
+    header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
 };
-declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
-declare type InfiniteTableComputedColumnBase<T> = {
-    computedWidth: number;
-    computedOffset: number;
-    computedPinningOffset: number;
-    computedAbsoluteOffset: number;
-    computedSortable: boolean;
-    computedSortInfo: DataSourceSingleSortInfo<T> | null;
-    computedSorted: boolean;
-    computedSortedAsc: boolean;
-    computedSortedDesc: boolean;
-    computedSortIndex: number;
-    computedVisibleIndex: number;
-    computedMultiSort: boolean;
-    computedPinned: InfiniteTableColumnPinnedValues;
-    computedDraggable: boolean;
-    computedFirstInCategory: boolean;
-    computedLastInCategory: boolean;
-    computedFirst: boolean;
-    computedLast: boolean;
-    toggleSort: () => void;
+declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
     id: string;
+    groupOffset: number;
+    computedWidth: number;
+    uniqueGroupId: string[];
+    columns: string[];
+    depth: number;
 };
-declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
-declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
-
-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>;
-}
-declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
-declare type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
-    field?: keyof T;
+declare type InfiniteTableGroupColumnGetterOptions<T> = {
+    groupIndexForColumn?: number;
+    groupByForColumn?: DataSourceGroupBy<T>;
+    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
+    groupCount: number;
+    groupBy: DataSourceGroupBy<T>[];
+    pivotBy?: DataSourcePivotBy<T>[];
+};
+declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
+    column: COL_TYPE;
+    groupBy: DataSourcePropGroupBy<T>;
+    pivotBy: DataSourcePropPivotBy<T>;
+};
+declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
+declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
+    renderValue?: InfiniteTableColumnRenderFunction<T>;
+    renderGroupIcon?: InfiniteTableGroupColumnRenderIconFunction<T>;
     id?: string;
 };
-declare type DataSourceGroupBy<T> = GroupBy<T, any>;
-declare type DataSourcePivotBy<T> = PivotBy<T, any>;
+declare type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
+    renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
+};
+declare type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
+declare type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
+declare type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
+declare type InfiniteTablePropComponents = {
+    LoadMask?: React$1.FC<LoadMaskProps>;
+};
+declare type ScrollStopInfo = {
+    scrollTop: number;
+    firstVisibleRowIndex: number;
+    lastVisibleRowIndex: number;
+};
+interface InfiniteTableProps<T> {
+    columns: InfiniteTablePropColumns<T>;
+    pivotColumns?: InfiniteTablePropColumnsMap<T, InfiniteTablePivotColumn<T>>;
+    loadingText?: Renderable;
+    components?: InfiniteTablePropComponents;
+    viewportReservedWidth?: number;
+    pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
+    pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
+    pivotGrandTotalColumnPosition?: InfiniteTablePropPivotGrandTotalColumnPosition;
+    groupColumn?: Partial<InfiniteTablePropGroupColumn<T>>;
+    groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
+    hideEmptyGroupColumns?: boolean;
+    columnVisibility?: InfiniteTablePropColumnVisibility;
+    defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
+    pinnedStartMaxWidth?: number;
+    pinnedEndMaxWidth?: number;
+    columnPinning?: InfiniteTablePropColumnPinning;
+    defaultColumnPinning?: InfiniteTablePropColumnPinning;
+    columnSizing?: InfiniteTablePropColumnSizing;
+    defaultColumnSizing?: InfiniteTablePropColumnSizing;
+    onColumnSizingChange?: (columnSizing: InfiniteTablePropColumnSizing) => void;
+    pivotColumnGroups?: InfiniteTablePropColumnGroups;
+    columnGroups?: InfiniteTablePropColumnGroups;
+    defaultColumnGroups?: InfiniteTablePropColumnGroups;
+    defaultCollapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
+    collapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
+    onScrollbarsChange?: (scrollbars: Scrollbars) => void;
+    onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
+    columnTypes?: InfiniteTablePropColumnTypes<T>;
+    showSeparatePivotColumnForSingleAggregation?: boolean;
+    rowHeight: number | string;
+    rowStyle?: InfiniteTablePropRowStyle<T>;
+    rowClassName?: InfiniteTablePropRowClassName<T>;
+    headerHeight: number | string;
+    domProps?: React$1.HTMLProps<HTMLDivElement>;
+    showZebraRows?: boolean;
+    showHoverRows?: boolean;
+    sortable?: boolean;
+    draggableColumns?: boolean;
+    header?: boolean;
+    focusedClassName?: string;
+    focusedWithinClassName?: string;
+    focusedStyle?: React$1.CSSProperties;
+    focusedWithinStyle?: React$1.CSSProperties;
+    columnCssEllipsis?: boolean;
+    columnHeaderCssEllipsis?: boolean;
+    columnDefaultWidth?: number;
+    columnMinWidth?: number;
+    columnMaxWidth?: number;
+    resizableColumns?: boolean;
+    virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
+    virtualizeRows?: boolean;
+    defaultActiveIndex?: number;
+    activeIndex?: number;
+    onSelfFocus?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onSelfBlur?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onFocusWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onBlurWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
+    onScrollToTop?: () => void;
+    onScrollToBottom?: () => void;
+    scrollStopDelay?: number;
+    onScrollStop?: (param: ScrollStopInfo) => void;
+    scrollToBottomOffset?: number;
+    defaultColumnOrder?: InfiniteTablePropColumnOrder;
+    columnOrder?: InfiniteTablePropColumnOrder;
+    onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrder) => void;
+    onRowHeightChange?: (rowHeight: number) => void;
+    onReady?: (api: InfiniteTableImperativeApi<T>) => void;
+    rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStyleFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
+    licenseKey?: string;
+    scrollTopKey?: string | number;
+    autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
+}
+declare type InfiniteTablePropAutoSizeColumnsKey = string | number | {
+    key: string | number;
+    columnsToSkip?: string[];
+    columnsToResize?: string[];
+    includeHeader?: boolean;
+};
+declare type Scrollbars = {
+    vertical: boolean;
+    horizontal: boolean;
+};
+
+declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
+    id: string;
+};
+declare type AggregationReducerResult<AggregationResultType extends any = any> = {
+    value: AggregationResultType;
+    id: string;
+};
+declare type InfiniteTableRowInfoNormalType<DataType> = {
+    data: DataType;
+    isGroupRow: false;
+};
+declare type InfiniteTableRowInfoGroupType<DataType> = {
+    data: Partial<DataType> | null;
+    isGroupRow: true;
+};
+declare type InfiniteTableRowInfoNormal<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoNormalType<T>;
+declare type InfiniteTableRowInfoGroup<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoGroupType<T>;
+declare type InfiniteTableRowInfo<T> = InfiniteTableRowInfoNormal<T> | InfiniteTableRowInfoGroup<T>;
+declare type InfiniteTableRowInfoBase<T> = {
+    id: any;
+    value?: any;
+    groupData?: T[];
+    collapsed: boolean;
+    collapsedChildrenCount?: number;
+    collapsedGroupsCount?: number;
+    groupNesting?: number;
+    groupKeys?: any[];
+    flatRowInfoList?: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
+    parents?: InfiniteTableEnhancedGroupInfo<T>[];
+    indexInParentGroups?: number[];
+    indexInGroup: number;
+    indexInAll: number;
+    groupCount?: number;
+    groupBy?: (keyof T)[];
+    rootGroupBy?: (keyof T)[];
+    pivotValuesMap?: PivotValuesDeepMap<T, any>;
+    reducerResults?: Record<string, AggregationReducerResult>;
+};
+declare type InfiniteTableEnhancedGroupInfo<T> = InfiniteTableRowInfo<T> & {
+    data: Partial<T> | null;
+    groupData: T[];
+    flatRowInfoList: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
+    value: any;
+    isGroupRow: true;
+    collapsedChildrenCount: number;
+    collapsedGroupsCount: number;
+    groupNesting: number;
+    groupKeys?: any[];
+    groupCount: number;
+    groupBy: (keyof T)[];
+    rootGroupBy: (keyof T)[];
+    pivotValuesMap?: PivotValuesDeepMap<T, any>;
+};
+declare type GroupKeyType<T extends any = any> = T;
+declare type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
+declare type PivotGroupValueType<DataType, KeyType> = {
+    reducerResults: PivotReducerResults<KeyType>;
+    items: DataType[];
+};
+declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
+declare type DeepMapGroupValueType<DataType, KeyType> = {
+    items: DataType[];
+    commonData?: Partial<DataType>;
+    reducerResults: Record<string, AggregationReducerResult>;
+    pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
+};
+declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
+};
+declare type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
+    column?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<DataType>>> | (({ column, }: {
+        column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
+    }) => Partial<InfiniteTablePivotColumn<DataType>>);
+    columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
+        columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
+    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnGroup<DataType>>>);
+};
+declare type GroupParams<DataType, KeyType> = {
+    groupBy: GroupBy<DataType, KeyType>[];
+    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
+    pivot?: PivotBy<DataType, KeyType>[];
+    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
+};
+declare type DataGroupResult<DataType, KeyType extends any> = {
+    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
+    groupParams: GroupParams<DataType, KeyType>;
+    initialData: DataType[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+    topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
+    pivot?: PivotBy<DataType, KeyType>[];
+};
+declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
+declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
+
+declare type RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
+};
+
+interface DataSourceDataParams<T> {
+    originalDataArray: T[];
+    sortInfo?: DataSourceSortInfo<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    lazyLoadBatchSize?: number;
+    lazyLoadStartIndex?: number;
+    groupKeys?: any[];
+    append?: boolean;
+    aggregationReducers?: DataSourcePropAggregationReducers<T>;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    __cursorId?: DataSourceSetupState<T>['cursorId'];
+    changes?: DataSourceDataParamsChanges<T>;
+}
+declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
+declare type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
+    field?: keyof T;
+    id?: string;
+};
+declare type DataSourceGroupBy<T> = GroupBy<T, any>;
+declare type DataSourcePivotBy<T> = PivotBy<T, any>;
 declare type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
 declare type DataSourceRemoteData<T> = {
     data: T[];
@@ -578,117 +1031,82 @@ interface DataSourceReducer<T> {
     (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
 }
 
-declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
-    id: string;
-};
-declare type AggregationReducerResult<AggregationResultType extends any = any> = {
-    value: AggregationResultType;
-    id: string;
+declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
+declare type InfiniteTableCellProps<T> = {
+    column: InfiniteTableComputedColumn<T>;
+    renderChildren: () => Renderable;
+    width: number;
+    cssEllipsis?: boolean;
+    virtualized?: boolean;
+    skipColumnShifting?: boolean;
+    beforeChildren?: Renderable;
+    afterChildren?: Renderable;
+    offset?: number;
+    offsetProperty?: 'left' | 'right';
+    cssPosition?: CSSProperties['position'];
+    domRef?: React.RefCallback<HTMLElement>;
+    cellType: 'body' | 'header';
 };
-declare type InfiniteTableRowInfoNormalType<DataType> = {
-    data: DataType;
-    isGroupRow: false;
+
+declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
+declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    sortTool: JSX.Element;
+    column: COL_TYPE;
+    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
 };
-declare type InfiniteTableRowInfoGroupType<DataType> = {
-    data: Partial<DataType> | null;
-    isGroupRow: true;
-};
-declare type InfiniteTableRowInfoNormal<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoNormalType<T>;
-declare type InfiniteTableRowInfoGroup<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoGroupType<T>;
-declare type InfiniteTableRowInfo<T> = InfiniteTableRowInfoNormal<T> | InfiniteTableRowInfoGroup<T>;
-declare type InfiniteTableRowInfoBase<T> = {
-    id: any;
-    value?: any;
-    groupData?: T[];
+declare type InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    value: string | number | Renderable;
+    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
+    rowIndex: number;
+    column: COL_TYPE;
+    toggleCurrentGroupRow: () => void;
+    toggleGroupRow: InfiniteTableToggleGroupRowFn;
+    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
+    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
+} & ({
+    rowInfo: InfiniteTableRowInfoNormal<DATA_TYPE>;
+    data: DATA_TYPE;
+} | {
+    rowInfo: InfiniteTableRowInfoGroup<DATA_TYPE>;
+    data: Partial<DATA_TYPE> | null;
+});
+declare type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParams<DATA_TYPE> & {};
+declare type InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE> & {
     collapsed: boolean;
-    collapsedChildrenCount?: number;
-    collapsedGroupsCount?: number;
-    groupNesting?: number;
-    groupKeys?: any[];
-    flatRowInfoList?: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
-    parents?: InfiniteTableEnhancedGroupInfo<T>[];
-    indexInParentGroups?: number[];
-    indexInGroup: number;
-    indexInAll: number;
-    groupCount?: number;
-    groupBy?: (keyof T)[];
-    rootGroupBy?: (keyof T)[];
-    pivotValuesMap?: PivotValuesDeepMap<T, any>;
-    reducerResults?: Record<string, AggregationReducerResult>;
-};
-declare type InfiniteTableEnhancedGroupInfo<T> = InfiniteTableRowInfo<T> & {
-    data: Partial<T> | null;
-    groupData: T[];
-    flatRowInfoList: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
-    value: any;
-    isGroupRow: true;
-    collapsedChildrenCount: number;
-    collapsedGroupsCount: number;
-    groupNesting: number;
-    groupKeys?: any[];
-    groupCount: number;
-    groupBy: (keyof T)[];
-    rootGroupBy: (keyof T)[];
-    pivotValuesMap?: PivotValuesDeepMap<T, any>;
-};
-declare type GroupKeyType<T extends any = any> = T;
-declare type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
-declare type PivotGroupValueType<DataType, KeyType> = {
-    reducerResults: PivotReducerResults<KeyType>;
-    items: DataType[];
-};
-declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
-declare type DeepMapGroupValueType<DataType, KeyType> = {
-    items: DataType[];
-    commonData?: Partial<DataType>;
-    reducerResults: Record<string, AggregationReducerResult>;
-    pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
-};
-declare type GroupBy<DataType, KeyType> = {
-    field: keyof DataType;
-    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
-    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
-};
-declare type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
-    column?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<DataType>>> | (({ column, }: {
-        column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
-    }) => Partial<InfiniteTablePivotColumn<DataType>>);
-    columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
-        columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
-    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnGroup<DataType>>>);
-};
-declare type GroupParams<DataType, KeyType> = {
-    groupBy: GroupBy<DataType, KeyType>[];
-    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
-    pivot?: PivotBy<DataType, KeyType>[];
-    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
-};
-declare type DataGroupResult<DataType, KeyType extends any> = {
-    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
-    groupParams: GroupParams<DataType, KeyType>;
-    initialData: DataType[];
-    reducerResults?: Record<string, AggregationReducerResult>;
-    topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
-    pivot?: PivotBy<DataType, KeyType>[];
-};
-declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
-declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
-
-declare type LoadMaskProps = {
-    visible: boolean;
-    children: Renderable;
+    groupIcon: Renderable;
 };
-
-declare type InfiniteTablePropColumnOrderNormalized = string[];
-declare type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
-declare type InfiniteTablePropColumnVisibility = Record<string, false>;
-declare type InfiniteTablePropColumnPinningMap = Map<string, true | 'start' | 'end'>;
-declare type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
-declare type InfiniteTablePropColumnPinningRecord = Record<string, true | 'start' | 'end'>;
-declare type InfiniteTablePropColumnPinning = InfiniteTablePropColumnPinningRecord | InfiniteTablePropColumnPinningMap;
-declare type InfiniteTableRowStyleFnParams<T> = {
+declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE>;
+declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
+    data: DATA_TYPE | Partial<DATA_TYPE> | null;
+    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
     rowIndex: number;
-    groupBy?: (keyof T)[];
+    column: COL_TYPE;
+};
+declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupBy, pivotBy, }: InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE>) => Renderable | null;
+declare type InfiniteTableGroupColumnRenderIconFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (param: InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
+declare type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderParams<T>) => Renderable;
+declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
+declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
+declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
+declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
+declare type InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T> = RequireAtLeastOne<{
+    /**
+     * Determines the field property of the column.
+     */
+    field?: keyof T;
+    render?: InfiniteTableColumnRenderFunction<T>;
+    renderValue?: InfiniteTableColumnRenderFunction<T>;
+    valueGetter?: InfiniteTableColumnValueGetter<T>;
+}, 'render' | 'renderValue' | 'field' | 'valueGetter'>;
+declare type InfiniteTableColumnStyleFnParams<T> = {
+    value: Renderable;
+    column: InfiniteTableColumn<T>;
 } & ({
     data: T;
     rowInfo: InfiniteTableRowInfoNormal<T>;
@@ -696,353 +1114,111 @@ declare type InfiniteTableRowStyleFnParams<T> = {
     data: Partial<T> | null;
     rowInfo: InfiniteTableRowInfoGroup<T>;
 });
-declare type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
-declare type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
-declare type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
-declare type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
-declare type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
-    getter?: AggregationReducer<T, AggregationResultType>['getter'];
-    field?: keyof T;
+declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
+declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
+declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
+declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
+declare type InfiniteTableColumnValueGetterParams<T> = {
+    data: T;
+    rowInfo: InfiniteTableRowInfoNormal<T>;
+} | {
+    data: Partial<T> | null;
+    rowInfo: InfiniteTableRowInfoGroup<T>;
 };
-declare type InfiniteTableColumnType<T> = {
-    minWidth?: number;
-    maxWidth?: number;
-    defaultWidth?: number;
-    defaultFlex?: number;
-    defaultPinned?: InfiniteTableColumnPinnedValues;
-    defaultHiddenWhenGroupedBy?: InfiniteTableColumn<T>['defaultHiddenWhenGroupedBy'];
-    header?: InfiniteTableColumn<T>['header'];
-    comparer?: InfiniteTableColumn<T>['comparer'];
-    draggable?: InfiniteTableColumn<T>['draggable'];
-    sortable?: InfiniteTableColumn<T>['sortable'];
-    resizable?: InfiniteTableColumn<T>['resizable'];
-    align?: InfiniteTableColumn<T>['align'];
-    verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
+declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
+declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
+declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
+declare type InfiniteTableBaseColumn<T> = {
+    sortable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    comparer?: InfiniteTableColumnComparer<T>;
+    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
+        [k in keyof Partial<T>]: true;
+    };
+    align?: InfiniteTableColumnAlign;
+    verticalAlign?: InfiniteTableColumnVerticalAlign;
+    columnGroup?: string;
+    header?: InfiniteTableColumnHeader<T>;
+    name?: Renderable;
     cssEllipsis?: boolean;
     headerCssEllipsis?: boolean;
-    components?: InfiniteTableColumn<T>['components'];
-    renderValue?: InfiniteTableColumn<T>['renderValue'];
-    render?: InfiniteTableColumn<T>['render'];
-    valueGetter?: InfiniteTableColumn<T>['valueGetter'];
-    style?: InfiniteTableColumn<T>['style'];
-};
-declare type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
-declare type InfiniteTableColumnSizingOptions = {
-    flex?: number;
-    width?: number;
+    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
+    style?: InfiniteTableColumnStyle<T>;
+    className?: InfiniteTableColumnClassName<T>;
+    rowspan?: InfiniteTableColumnRowspanFn<T>;
+    valueGetter?: InfiniteTableColumnValueGetter<T>;
+    defaultWidth?: number;
+    defaultFlex?: number;
     minWidth?: number;
     maxWidth?: number;
+    components?: {
+        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+    };
 };
-declare type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
-declare type InfiniteTableImperativeApi<T> = {
-    setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
-    setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
-    x?: T;
-    getState: () => InfiniteTableState<T>;
-    getDataSourceState: () => DataSourceState<T>;
-};
-declare type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
-declare type InfiniteTablePropColumnsMap<T, ColumnType = InfiniteTableColumn<T>> = Map<string, ColumnType>;
-declare type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = InfiniteTablePropColumnsMap<T, ColumnType> | Record<string, ColumnType>;
-declare type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
-declare type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
-declare type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
-declare type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
-declare type InfiniteTableColumnGroupHeaderRenderParams = {
-    columnGroup: InfiniteTableComputedColumnGroup;
-};
-declare type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
-declare type InfiniteTableColumnGroup = {
-    columnGroup?: string;
-    header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
+/**
+ * Defines a column in the table.
+ *
+ * @typeParam DATA_TYPE The type of the data in the table.
+ *
+ * Can be bound to a field which is a `keyof DATA_TYPE`.
+ */
+declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<DATA_TYPE>;
+declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
+    groupByField: string | string[];
+    id?: string;
 };
-declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
-    id: string;
-    groupOffset: number;
-    computedWidth: number;
-    uniqueGroupId: string[];
-    columns: string[];
-    depth: number;
+declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
+declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotTotalColumnGroup?: true;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex: PivotBy<DataType, KeyType>;
+    pivotGroupKey: KeyType;
+    pivotIndex: number;
 };
-declare type InfiniteTableGroupColumnGetterOptions<T> = {
-    groupIndexForColumn?: number;
-    groupByForColumn?: DataSourceGroupBy<T>;
-    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
-    groupCount: number;
-    groupBy: DataSourceGroupBy<T>[];
-    pivotBy?: DataSourcePivotBy<T>[];
-};
-declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
-    column: COL_TYPE;
-    groupBy: DataSourcePropGroupBy<T>;
-    pivotBy: DataSourcePropPivotBy<T>;
-};
-declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
-declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
-    renderGroupIcon?: InfiniteTableGroupColumnRenderIconFunction<T>;
-    id?: string;
-};
-declare type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
-    renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
-};
-declare type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
-declare type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
-declare type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
-declare type InfiniteTablePropComponents = {
-    LoadMask?: React$1.FC<LoadMaskProps>;
-};
-declare type ScrollStopInfo = {
-    scrollTop: number;
-    firstVisibleRowIndex: number;
-    lastVisibleRowIndex: number;
-};
-interface InfiniteTableProps<T> {
-    columns: InfiniteTablePropColumns<T>;
-    pivotColumns?: InfiniteTablePropColumnsMap<T, InfiniteTablePivotColumn<T>>;
-    loadingText?: Renderable;
-    components?: InfiniteTablePropComponents;
-    viewportReservedWidth?: number;
-    pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
-    pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
-    pivotGrandTotalColumnPosition?: InfiniteTablePropPivotGrandTotalColumnPosition;
-    groupColumn?: Partial<InfiniteTablePropGroupColumn<T>>;
-    groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
-    hideEmptyGroupColumns?: boolean;
-    columnVisibility?: InfiniteTablePropColumnVisibility;
-    defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
-    pinnedStartMaxWidth?: number;
-    pinnedEndMaxWidth?: number;
-    columnPinning?: InfiniteTablePropColumnPinning;
-    defaultColumnPinning?: InfiniteTablePropColumnPinning;
-    columnSizing?: InfiniteTablePropColumnSizing;
-    defaultColumnSizing?: InfiniteTablePropColumnSizing;
-    onColumnSizingChange?: (columnSizing: InfiniteTablePropColumnSizing) => void;
-    pivotColumnGroups?: InfiniteTablePropColumnGroups;
-    columnGroups?: InfiniteTablePropColumnGroups;
-    defaultColumnGroups?: InfiniteTablePropColumnGroups;
-    defaultCollapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
-    collapsedColumnGroups?: InfiniteTablePropCollapsedColumnGroups;
-    onScrollbarsChange?: (scrollbars: Scrollbars) => void;
-    onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
-    columnTypes?: InfiniteTablePropColumnTypes<T>;
-    showSeparatePivotColumnForSingleAggregation?: boolean;
-    rowHeight: number | string;
-    rowStyle?: InfiniteTablePropRowStyle<T>;
-    rowClassName?: InfiniteTablePropRowClassName<T>;
-    headerHeight: number | string;
-    domProps?: React$1.HTMLProps<HTMLDivElement>;
-    showZebraRows?: boolean;
-    showHoverRows?: boolean;
-    sortable?: boolean;
-    draggableColumns?: boolean;
-    header?: boolean;
-    focusedClassName?: string;
-    focusedWithinClassName?: string;
-    focusedStyle?: React$1.CSSProperties;
-    focusedWithinStyle?: React$1.CSSProperties;
-    columnCssEllipsis?: boolean;
-    columnHeaderCssEllipsis?: boolean;
-    columnDefaultWidth?: number;
-    columnMinWidth?: number;
-    columnMaxWidth?: number;
-    resizableColumns?: boolean;
-    virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
-    virtualizeRows?: boolean;
-    defaultActiveIndex?: number;
-    activeIndex?: number;
-    onSelfFocus?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onSelfBlur?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onFocusWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onBlurWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
-    onScrollToTop?: () => void;
-    onScrollToBottom?: () => void;
-    scrollStopDelay?: number;
-    onScrollStop?: (param: ScrollStopInfo) => void;
-    scrollToBottomOffset?: number;
-    defaultColumnOrder?: InfiniteTablePropColumnOrder;
-    columnOrder?: InfiniteTablePropColumnOrder;
-    onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrder) => void;
-    onRowHeightChange?: (rowHeight: number) => void;
-    onReady?: (api: InfiniteTableImperativeApi<T>) => void;
-    rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStyleFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
-    licenseKey?: string;
-    scrollTopKey?: string | number;
-    autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
-}
-declare type InfiniteTablePropAutoSizeColumnsKey = string | number | {
-    key: string | number;
-    columnsToSkip?: string[];
-    columnsToResize?: string[];
-    includeHeader?: boolean;
-};
-declare type Scrollbars = {
-    vertical: boolean;
-    horizontal: boolean;
+declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotColumn: true;
+    pivotTotalColumn: boolean;
+    pivotAggregator: AggregationReducer<DataType, any>;
+    pivotAggregatorIndex: number;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex?: PivotBy<DataType, KeyType>;
+    pivotIndex: number;
+    pivotGroupKey: KeyType;
 };
-
-declare class ScrollListener {
-    private scrollPosition;
-    private onScrollFns;
-    getScrollPosition: () => ScrollPosition;
-    onScroll: (fn: OnScrollFn) => () => void;
-    setScrollPosition: (scrollPosition: ScrollPosition) => void;
-    private notifyScrollChange;
-    destroy: () => void;
-}
-
-interface InfiniteTableSetupState<T> {
-    propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
-    columnsWhenInlineGroupRenderStrategy?: Map<string, InfiniteTableColumn<T>>;
-    domRef: MutableRefObject<HTMLDivElement | null>;
-    scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
-    portalDOMRef: MutableRefObject<HTMLDivElement | null>;
-    onRowHeightCSSVarChange: SubscriptionCallback<number>;
-    onHeaderHeightCSSVarChange: SubscriptionCallback<number>;
-    columnsWhenGrouping?: InfiniteTablePropColumnsMap<T>;
-    bodySize: Size;
-    verticalVirtualBrain: VirtualBrain;
-    horizontalVirtualBrain: VirtualBrain;
-    focused: boolean;
-    ready: boolean;
-    focusedWithin: boolean;
-    scrollPosition: ScrollPosition;
-    draggingColumnId: null | string;
-    pinnedStartScrollListener: ScrollListener;
-    pinnedEndScrollListener: ScrollListener;
-    columnShifts: number[] | null;
-}
-declare type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
-declare type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
-declare type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
-interface InfiniteTableMappedState<T> {
-    scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
-    viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
-    groupColumn: InfiniteTableProps<T>['groupColumn'];
-    onScrollbarsChange: InfiniteTableProps<T>['onScrollbarsChange'];
-    loadingText: InfiniteTableProps<T>['loadingText'];
-    components: InfiniteTableProps<T>['components'];
-    columns: InfiniteTablePropColumnsMap<T>;
-    pivotColumns: InfiniteTableProps<T>['pivotColumns'];
-    onReady: InfiniteTableProps<T>['onReady'];
-    onSelfFocus: InfiniteTableProps<T>['onSelfFocus'];
-    onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
-    onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
-    onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
-    autoSizeColumnsKey: InfiniteTableProps<T>['autoSizeColumnsKey'];
-    scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
-    onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
-    onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
-    onScrollStop: InfiniteTableProps<T>['onScrollStop'];
-    scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
-    focusedClassName: InfiniteTableProps<T>['focusedClassName'];
-    focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
-    focusedStyle: InfiniteTableProps<T>['focusedStyle'];
-    focusedWithinStyle: InfiniteTableProps<T>['focusedWithinStyle'];
-    showSeparatePivotColumnForSingleAggregation: NonUndefined<InfiniteTableProps<T>['showSeparatePivotColumnForSingleAggregation']>;
-    domProps: InfiniteTableProps<T>['domProps'];
-    rowStyle: InfiniteTableProps<T>['rowStyle'];
-    rowProps: InfiniteTableProps<T>['rowProps'];
-    rowClassName: InfiniteTableProps<T>['rowClassName'];
-    pinnedStartMaxWidth: InfiniteTableProps<T>['pinnedStartMaxWidth'];
-    pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
-    pivotColumn: InfiniteTableProps<T>['pivotColumn'];
-    pivotColumnGroups: InfiniteTablePropColumnGroupsMap;
-    activeIndex: NonUndefined<InfiniteTableProps<T>['activeIndex']>;
-    columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
-    columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
-    columnDefaultWidth: NonUndefined<InfiniteTableProps<T>['columnDefaultWidth']>;
-    columnCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnCssEllipsis']>;
-    draggableColumns: NonUndefined<InfiniteTableProps<T>['draggableColumns']>;
-    sortable: NonUndefined<InfiniteTableProps<T>['sortable']>;
-    hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
-    columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
-    showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
-    showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
-    header: NonUndefined<InfiniteTableProps<T>['header']>;
-    virtualizeColumns: NonUndefined<InfiniteTableProps<T>['virtualizeColumns']>;
-    rowHeight: number;
-    headerHeight: number;
-    licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
-    columnVisibility: InfiniteTablePropColumnVisibility;
-    columnPinning: InfiniteTablePropColumnPinningMap;
-    columnSizing: InfiniteTablePropColumnSizing;
-    columnTypes: InfiniteTablePropColumnTypes<T>;
-    columnGroups: InfiniteTablePropColumnGroupsMap;
-    collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
-    pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
-    pivotGrandTotalColumnPosition: InfiniteTableProps<T>['pivotGrandTotalColumnPosition'];
-}
-interface InfiniteTableDerivedState<T> {
-    groupBy: DataSourceProps<T>['groupBy'];
-    computedColumns: Map<string, InfiniteTableColumn<T>>;
-    virtualizeHeader: boolean;
-    groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
-    columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
-    columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
-    columnGroupsMaxDepth: number;
-    computedColumnGroups: InfiniteTablePropColumnGroupsMap;
-    rowHeightCSSVar: string;
-    headerHeightCSSVar: string;
-    controlledColumnVisibility: boolean;
-}
-declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
-interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
-}
-
-declare enum InfiniteTableActionType {
-    SET_COLUMN_SIZE = 0,
-    SET_SCROLL_POSITION = 1,
-    SET_BODY_SIZE = 2,
-    SET_COLUMN_ORDER = 3,
-    SET_COLUMN_VISIBILITY = 4,
-    SET_COLUMN_SHIFTS = 5,
-    SET_COLUMN_PINNING = 6,
-    SET_COLUMN_AGGREGATIONS = 7,
-    SET_DRAGGING_COLUMN_ID = 8
-}
-
-declare type InfiniteTableAction = {
-    type: InfiniteTableActionType;
-    payload?: any;
+declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
+declare type InfiniteTableComputedColumnBase<T> = {
+    computedWidth: number;
+    computedOffset: number;
+    computedPinningOffset: number;
+    computedAbsoluteOffset: number;
+    computedSortable: boolean;
+    computedSortInfo: DataSourceSingleSortInfo<T> | null;
+    computedSorted: boolean;
+    computedSortedAsc: boolean;
+    computedSortedDesc: boolean;
+    computedSortIndex: number;
+    computedVisibleIndex: number;
+    computedMultiSort: boolean;
+    computedPinned: InfiniteTableColumnPinnedValues;
+    computedDraggable: boolean;
+    computedFirstInCategory: boolean;
+    computedLastInCategory: boolean;
+    computedFirst: boolean;
+    computedLast: boolean;
+    toggleSort: () => void;
+    id: string;
 };
+declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
+declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 
-interface InfiniteTableComputedValues<T> {
-    rowSpan?: VirtualBrainOptions['itemSpan'];
-    computedPinnedStartOverflow: boolean;
-    computedPinnedEndOverflow: boolean;
-    computedPinnedStartColumns: InfiniteTableComputedColumn<T>[];
-    computedPinnedEndColumns: InfiniteTableComputedColumn<T>[];
-    computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
-    computedVisibleColumns: InfiniteTableComputedColumn<T>[];
-    computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
-    computedColumnVisibility: InfiniteTablePropColumnVisibility;
-    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
-    computedPinnedStartColumnsWidth: number;
-    computedPinnedStartWidth: number;
-    computedPinnedEndColumnsWidth: number;
-    computedPinnedEndWidth: number;
-    computedUnpinnedColumnsWidth: number;
-    computedUnpinnedOffset: number;
-    computedPinnedEndOffset: number;
-    computedRemainingSpace: number;
-    unpinnedColumnRenderCount: number;
-    columnRenderStartIndex: number;
-    toggleGroupRow: (groupKeys: any[]) => void;
-}
-
-interface InfiniteTableContextValue<T> {
-    componentState: InfiniteTableState<T>;
-    componentActions: InfiniteTableActions<T>;
-    computed: InfiniteTableComputedValues<T>;
-    getComputed: () => InfiniteTableComputedValues<T>;
-    getState: () => InfiniteTableState<T>;
-}
+declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParams<T, InfiniteTableComputedColumn<T>>;
 
 declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
 
-declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParams<T, InfiniteTableComputedColumn<T>>;
-
 declare const InfiniteTableClassName: string;
 declare const InfiniteTableComponent: React$1.MemoExoticComponent<(<T>() => JSX.Element)>;
 declare function InfiniteTable<T>(props: InfiniteTableProps<T>): JSX.Element;
@@ -1106,6 +1282,6 @@ declare type InterceptedMapFns<K, V> = {
  */
 declare function interceptMap<K, V>(map: Map<K, V>, fns: InterceptedMapFns<K, V>): () => void;
 
-declare function useEffectWithChanges(fn: (changes: Record<string, any>, prevValues: Record<string, any>) => void | (() => void), deps: Record<string, any>): void;
+declare function useEffectWithChanges<T>(fn: (changes: Record<keyof T, any>, prevValues: Record<string, any>) => void | (() => void), deps: Record<keyof T, any>): void;
 
 export { ColumnTypeWithInherit, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceExpandedAndCollapsedGroupRows, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropGroupBy, DataSourcePropLivePaginationCursor, DataSourcePropPivotBy, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderParams as InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTableGroupColumnRenderIconFunction, InfiniteTableImperativeApi, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, LazyGroupDataDeepMap, LazyGroupDataItem, LazyGroupRowInfo, Scrollbars, debounce, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };