@infinite-table/infinite-react 0.2.20 → 0.3.1

package/index.d.ts

@@ -1,41 +1,11 @@
 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 SortDir = 1 | -1;
-declare type MultisortInfo<T> = {
-    /**
-     * The sorting direction
-     */
-    dir: SortDir;
-    /**
-     * a property whose value to use for sorting on the array items
-     */
-    field?: keyof T;
-    /**
-     * for now 'string' and 'number' are known types, meaning they have
-     * sort functions already implemented
-     */
-    type?: string;
-    fn?: (a: any, b: any) => number;
-};
-declare const multisort: {
-    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
-    knownTypes: {
-        [key: string]: (first: any, second: any) => number;
-    };
-};
-
 declare type VoidFn$1 = () => void;
 declare type Pair<KeyType, ValueType> = {
     value?: ValueType;
@@ -50,6 +20,10 @@ 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[];
+    getKeysStartingWith(keys: KeyType[]): KeyType[][];
+    private getStartingWith;
+    getDirectChildrenSizeFor(keys: KeyType[]): number;
     set(keys: KeyType[] & {
         length: Omit<number, 0>;
     }, value: ValueType): this;
@@ -72,6 +46,30 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
+declare type SortDir = 1 | -1;
+declare type MultisortInfo<T> = {
+    /**
+     * The sorting direction
+     */
+    dir: SortDir;
+    /**
+     * a property whose value to use for sorting on the array items
+     */
+    field?: keyof T;
+    /**
+     * for now 'string' and 'number' are known types, meaning they have
+     * sort functions already implemented
+     */
+    type?: string;
+    fn?: (a: any, b: any) => number;
+};
+declare const multisort: {
+    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
+};
+
 declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
     getComponentState: () => T_STATE;
     componentState: T_STATE;
@@ -88,39 +86,22 @@ declare type ComponentInterceptedActions<T_STATE> = {
 };
 declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
 
-declare class GroupRowsState<KeyType extends any = any> {
-    private expandedMap?;
-    private collapsedMap?;
-    private collapsedAll;
-    private expandedAll;
-    private initialState;
-    constructor(state: DataSourceExpandedAndCollapsedGroupRows<KeyType> | GroupRowsState<KeyType>);
-    getState(): DataSourceExpandedAndCollapsedGroupRows<KeyType>;
-    destroy(): void;
-    private update;
-    areAllCollapsed(): boolean;
-    areAllExpanded(): boolean;
-    collapseAll(): void;
-    expandAll(): void;
-    isGroupRowExpanded(keys: KeyType[]): boolean | undefined;
-    isGroupRowCollapsed(keys: KeyType[]): boolean;
-    setGroupRowExpanded(keys: KeyType[], shouldExpand: boolean): void;
-    collapseGroupRow(keys: KeyType[]): void;
-    expandGroupRow(keys: KeyType[]): void;
-    toggleGroupRow(keys: KeyType[]): void;
+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 NonUndefined<T> = T extends undefined ? never : T;
-
-declare type VoidFn = () => void;
-
-declare type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
-interface SubscriptionCallback<T> {
-    (node: T): void;
-    get: () => T | null;
-    destroy: VoidFn;
-    onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
-}
+declare type InfiniteTableAction = {
+    type: InfiniteTableActionType;
+    payload?: any;
+};
 
 interface LogFn {
     (...args: any[]): LogFn;
@@ -132,301 +113,651 @@ declare class Logger {
     constructor(channelName: string);
 }
 
+interface ScrollPosition {
+    scrollTop: number;
+    scrollLeft: number;
+}
+declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
+
 interface Size {
     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;
+declare type VoidFn = () => void;
+
+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 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 ItemSizeFunction = (index: number) => number;
+declare type MatrixBrainOptions = {
+    width: number;
+    height: number;
+    cols: number;
+    rows: number;
+    rowHeight: number | ItemSizeFunction;
+    colWidth: number | ItemSizeFunction;
+    rowspan?: SpanFunction;
+    colspan?: SpanFunction;
+};
+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;
 
-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 SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
+interface SubscriptionCallback<T> {
+    (node: T, callback?: () => void): void;
+    get: () => T | null;
+    destroy: VoidFn;
+    onChange: (fn: SubscriptionCallbackOnChangeFn<T>) => VoidFn;
+}
 
-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 class ScrollListener {
+    private scrollPosition;
+    private onScrollFns;
+    getScrollPosition: () => ScrollPosition;
+    onScroll: (fn: OnScrollFn) => () => void;
+    setScrollPosition: (scrollPosition: ScrollPosition) => void;
+    private notifyScrollChange;
+    destroy: () => void;
+}
 
-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;
-};
-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;
-    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>;
-} | {
-    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 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 NonUndefined<T> = T extends undefined ? never : T;
+
+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 LoadMaskProps = {
+    visible: boolean;
+    children: 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> = {
+    rowIndex: number;
+} & InfiniteTableRowInfoDataDiscriminator<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 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;
-    id?: string;
+declare type InfiniteTableGroupColumnGetterOptions<T> = {
+    groupIndexForColumn?: number;
+    groupByForColumn?: DataSourceGroupBy<T>;
+    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
+    groupCount: number;
+    groupBy: DataSourceGroupBy<T>[];
+    pivotBy?: DataSourcePivotBy<T>[];
 };
-declare type DataSourceGroupBy<T> = GroupBy<T, any>;
+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;
+};
+
+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 RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
+};
+
+interface DataSourceDataParams<T> {
+    originalDataArray: T[];
+    sortInfo?: DataSourceSortInfo<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
+    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[];
+    data: T[] | LazyGroupDataItem<T>[];
     mappings?: DataSourceMappings;
     cache?: boolean;
     totalCount?: number;
@@ -434,7 +765,7 @@ declare type DataSourceRemoteData<T> = {
 };
 declare type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
 declare type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
-declare type DataSourceExpandedAndCollapsedGroupRows<KeyType> = {
+declare type DataSourcePropGroupRowsStateObject<KeyType> = {
     expandedRows: DataSourceGroupRowsList<KeyType>;
     collapsedRows: DataSourceGroupRowsList<KeyType>;
 };
@@ -448,7 +779,7 @@ interface DataSourceMappedState<T> {
     data: DataSourceProps<T>['data'];
     primaryKey: DataSourceProps<T>['primaryKey'];
     groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
-    groupRowsState: NonUndefined<DataSourceProps<T>['groupRowsState']>;
+    groupRowsState: GroupRowsState<T>;
     pivotBy: DataSourceProps<T>['pivotBy'];
     loading: NonUndefined<DataSourceProps<T>['loading']>;
     collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
@@ -473,18 +804,26 @@ declare type LazyGroupDataItem<DataType> = {
     data: Partial<DataType>;
     keys: any[];
     aggregations?: Record<string, any>;
+    dataset?: DataSourceRemoteData<DataType>;
     pivot?: {
         values: Record<string, any>;
         totals?: Record<string, any>;
     };
 };
-declare type LazyGroupRowInfo<DataType> = {
-    items: LazyGroupDataItem<DataType>[];
+declare type LazyRowInfoGroup<DataType> = {
+    /**
+     * Those are direct children of the current lazy group row
+     */
+    children: LazyGroupDataItem<DataType>[];
+    childrenLoading: boolean;
+    childrenAvailable: boolean;
+    cache: boolean;
     totalCount: number;
-    cache?: boolean;
+    error?: string;
 };
-declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyGroupRowInfo<DataType>>;
+declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
 interface DataSourceSetupState<T> {
+    lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
     pivotMappings?: DataSourceMappings;
     propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
     showSeparatePivotColumnForSingleAggregation: boolean;
@@ -502,7 +841,7 @@ interface DataSourceSetupState<T> {
     groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
     pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
     pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
-    cursorId: number | Symbol | DataSourceLivePaginationCursorValue;
+    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
     updatedAt: number;
     reducedAt: number;
     groupedAt: number;
@@ -533,8 +872,8 @@ declare type DataSourceProps<T> = {
     groupBy?: DataSourcePropGroupBy<T>;
     defaultGroupBy?: DataSourcePropGroupBy<T>;
     onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
-    groupRowsState?: GroupRowsState;
-    defaultGroupRowsState?: GroupRowsState;
+    groupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
+    defaultGroupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<keyof T>;
     onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
     collapseGroupRowsOnDataFunctionChange?: boolean;
     sortInfo?: DataSourceSortInfo<T>;
@@ -578,6 +917,28 @@ interface DataSourceReducer<T> {
     (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
 }
 
+declare class GroupRowsState<KeyType extends any = any> {
+    private expandedMap?;
+    private collapsedMap?;
+    private collapsedAll;
+    private expandedAll;
+    private initialState;
+    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
+    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
+    destroy(): void;
+    private update;
+    areAllCollapsed(): boolean;
+    areAllExpanded(): boolean;
+    collapseAll(): void;
+    expandAll(): void;
+    isGroupRowExpanded(keys: KeyType[]): boolean | undefined;
+    isGroupRowCollapsed(keys: KeyType[]): boolean;
+    setGroupRowExpanded(keys: KeyType[], shouldExpand: boolean): void;
+    collapseGroupRow(keys: KeyType[]): void;
+    expandGroupRow(keys: KeyType[]): void;
+    toggleGroupRow(keys: KeyType[]): void;
+}
+
 declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
     id: string;
 };
@@ -585,51 +946,191 @@ declare type AggregationReducerResult<AggregationResultType extends any = any> =
     value: AggregationResultType;
     id: string;
 };
-declare type InfiniteTableRowInfoNormalType<DataType> = {
-    data: DataType;
+/**
+ * InfiniteTableRowInfo can have different object shape depending on the presence or absence of grouping.
+ *
+ * You can use `dataSourceHasGrouping: boolean` as a discriminator to determine the shape of the object, to know
+ * if the dataSource had grouping or not. Furthermore, for when the dataSource has grouping,
+ * you can use `isGroupRow: boolean` to discriminate between group rows vs normal rows.
+ *
+ */
+declare type InfiniteTableRowInfo<T> = InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T> | InfiniteTable_NoGrouping_RowInfoNormal<T>;
+declare type InfiniteTableRowInfoDataDiscriminator<T> = {
+    data: T;
     isGroupRow: false;
-};
-declare type InfiniteTableRowInfoGroupType<DataType> = {
-    data: Partial<DataType> | null;
+    rowInfo: InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoNormal<T>;
+} | {
+    data: Partial<T> | null;
+    rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<T>;
     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> = {
+/**
+ * This is the base row info for all scenarios - things every
+ * rowInfo is guaranteed to have (be it group or normal row, or dataSource with or without grouping)
+ *
+ */
+declare type InfiniteTable_RowInfoBase<_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> & {
+declare type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
+    dataSourceHasGrouping: true;
+    data: T;
+    isGroupRow: false;
+} & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
+declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
+    dataSourceHasGrouping: true;
     data: Partial<T> | null;
-    groupData: T[];
-    flatRowInfoList: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
-    value: any;
     isGroupRow: true;
+    /**
+     * This array contains all the (uncollapsed, so visible) row infos under this group, at any level of nesting,
+     * in the order in which they are visible in the table
+     */
+    deepRowInfoArray: (InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T>)[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+    /**
+     * The count of all leaf nodes (normal rows) that are inside this group.
+     * This count is the same as the length of the groupData array property.
+     */
+    groupCount: number;
+    /**
+     * The array of all leaf nodes (normal rows) that are inside this group.
+     */
+    groupData: T[];
+    /**
+     * The count of all leaf nodes (normal rows) inside the group that are not being visible
+     * due to collapsing (either the current row is collapsed or any of its children)
+     */
     collapsedChildrenCount: number;
     collapsedGroupsCount: number;
-    groupNesting: number;
-    groupKeys?: any[];
-    groupCount: number;
+    /**
+     * The count of the direct children of the current group. Direct children can be either normal rows or groups.
+     */
+    directChildrenCount: number;
+    directChildrenLoadedCount: number;
+    /**
+     *
+     * A DeepMap of pivot values.
+     *
+     * For each pivot reducer result, it contains all the items that make up the pivot value.
+     *
+     */
+    pivotValuesMap?: PivotValuesDeepMap<T, any>;
+    /**
+     * For non-lazy grouping, this is always true.
+     * For lazy/batched grouping, this is true if the group has been expanded at least once (and if the remote call has been configured with cache: true),
+     * since if the remote call is not cached, collapsing the row group should lose all the data that was loaded for it, and it's as if it was never loaded, so in that case, childrenAvailable is false.
+     *
+     * NOTE: if this is true, it doesn't mean that all the children have been loaded, it only means that some children have been loaded and are available
+     *
+     * Use directChildrenCount and directChildrenLoadedCount to know if all the children have been loaded or not.
+     */
+    childrenAvailable: boolean;
+    /**
+     * Boolean flag that will be true while lazy loading direct children of the current row group.
+     *
+     * NOTE: with batched loading, if the user is no longer scrolling, after everything
+     * in the viewport has loaded (and thus for example a certain row group had childrenLoading: true)
+     * if no new batches are being loaded, childrenLoading will be false again, even though
+     * the current row group still has children that are not loaded yet.
+     * Use directChildrenLoadedCount and directChildrenCount to know if all the children have been loaded or not.
+     */
+    childrenLoading: boolean;
+} & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
+declare type InfiniteTable_NoGrouping_RowInfoNormal<T> = {
+    dataSourceHasGrouping: false;
+    data: T;
+    isGroupRow: false;
+    selfLoaded: boolean;
+} & InfiniteTable_RowInfoBase<T>;
+declare type InfiniteTable_HasGrouping_RowInfoBase<T> = {
+    indexInGroup: number;
+    /**
+     * Available on all rowInfo objects when the datasource is grouped, otherwise, it will be undefined.
+     *
+     * For group rows, the group keys will have all the keys starting from the topmost parent
+     * down to the current group row (including the group row).
+     * For normal rows, the group keys will have all the keys starting from the topmost parent
+     * down to the last group row in the hierarchy (the direct parent of the current row).
+     *
+     * Example: People grouped by country and city
+     *
+     * Italy  - country         - groupKeys: ['Italy']
+     *    Rome - city           - groupKeys: ['Italy', 'Rome']
+     *      Marco    - person   - groupKeys: ['Italy', 'Rome']
+     *      Luca     - person   - groupKeys: ['Italy', 'Rome']
+     *      Giuseppe  - person  - groupKeys: ['Italy', 'Rome']
+     *
+     */
+    groupKeys: any[];
+    /**
+     * Available on all rowInfo objects when the datasource is grouped, otherwise, it will be undefined.
+     *
+     * Has the same structure as groupKeys, but it will contain the fields used to group the rows.
+     *
+     * Example: People grouped by country and city
+     *
+     * Italy  - country         - groupKeys: ['country']
+     *    Rome - city           - groupKeys: ['country', 'city']
+     *      Marco    - person   - groupKeys: ['country', 'city']
+     *      Luca     - person   - groupKeys: ['country', 'city']
+     *      Giuseppe  - person  - groupKeys: ['country', 'city']
+     */
     groupBy: (keyof T)[];
+    /**
+     * The groupBy value of the DataSource component, mapped to the groupBy.field
+     */
     rootGroupBy: (keyof T)[];
-    pivotValuesMap?: PivotValuesDeepMap<T, any>;
+    /**
+     * Available on all rowInfo objects when the datasource is grouped.
+     *
+     * Italy  - country         - parent mapped to their ids will be: [] // rowInfo.parents.map((p: any) => p.id)
+     *    Rome - city           - parent mapped to their ids will be: ['Italy']
+     *      Marco    - person   - parent mapped to their ids will be: ['Italy','Italy,Rome']
+     *      Luca     - person   - parent mapped to their ids will be: ['Italy','Italy,Rome']
+     *      Giuseppe  - person  - parent mapped to their ids will be: ['Italy','Italy,Rome']
+     * USA - country            - parent mapped to their ids will be: []
+     *    LA - city             - parent mapped to their ids will be: ['USA']
+     *      Bob  - person       - parent mapped to their ids will be: ['USA','USA,LA']
+     */
+    parents: InfiniteTable_HasGrouping_RowInfoGroup<T>[];
+    /**
+     * Available when the datasource is grouped, this will be set for both group and normal rows.
+     * Italy  - country         - indexInParentGroups: [0]
+     *    Rome - city           - indexInParentGroups: [0,0]
+     *      Marco    - person   - indexInParentGroups: [0,0,0]
+     *      Luca     - person   - indexInParentGroups: [0,0,1]
+     *      Giuseppe  - person  - indexInParentGroups: [0,0,2]
+     * USA - country            - indexInParentGroups: [1]
+     *    LA - city             - indexInParentGroups: [1,0]
+     *      Bob  - person       - indexInParentGroups: [1,0,2]
+     */
+    indexInParentGroups: number[];
+    /**
+     * Available on all rowInfo objects when the datasource is grouped.
+     *
+     * For every rowInfo object, it counts the number of leaf/normal rows that the group contains.
+     * For normal rows, the groupCount represents the groupCount of the direct parent.
+     *
+     * Italy  - country         - groupCount: 3
+     *    Rome - city           - groupCount: 2
+     *      Marco    - person   - groupCount: 2
+     *      Luca     - person   - groupCount: 2
+     *    Napoli - city         - groupCount: 1
+     *      Giuseppe  - person  - groupCount: 1
+     * USA - country            - groupCount: 1
+     *    LA - city             - groupCount: 1
+     *      Bob  - person       - groupCount: 1
+     */
+    groupCount: number;
+    groupNesting: number;
+    collapsed: boolean;
+    /**
+     * This is false only when the DataSource is configured with lazy batching and the current
+     * row has not been loaded yet. It has nothing to do with children, only with self.
+     */
+    selfLoaded: boolean;
 };
 declare type GroupKeyType<T extends any = any> = T;
 declare type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
@@ -639,8 +1140,15 @@ declare type PivotGroupValueType<DataType, KeyType> = {
 };
 declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
 declare type DeepMapGroupValueType<DataType, KeyType> = {
+    /**
+     * These are leaf items. This array may be empty when there is batched lazy loading
+     */
     items: DataType[];
     commonData?: Partial<DataType>;
+    childrenLoading: boolean;
+    childrenAvailable: boolean;
+    cache: boolean;
+    error?: string;
     reducerResults: Record<string, AggregationReducerResult>;
     pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
 };
@@ -674,375 +1182,182 @@ declare type DataGroupResult<DataType, KeyType extends any> = {
 declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
 declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
 
-declare type LoadMaskProps = {
-    visible: boolean;
-    children: 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> = {
-    rowIndex: number;
-    groupBy?: (keyof 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 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 InfiniteTableCellProps<T> = {
+    column: InfiniteTableComputedColumn<T>;
+    renderChildren: () => Renderable;
+    width: number;
     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;
-};
-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>;
+    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 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 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 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 InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
-declare type InfiniteTableColumnGroup = {
-    columnGroup?: string;
-    header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
+declare type InfiniteTableColumnRenderParamBase<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'];
 };
-declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
-    id: string;
-    groupOffset: number;
-    computedWidth: number;
-    uniqueGroupId: string[];
-    columns: string[];
-    depth: number;
+declare type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
+declare type InfiniteTableGroupColumnRenderParams<DATA_TYPE, COL_TYPE> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & {
+    rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<DATA_TYPE>;
+    isGroupRow: true;
+    data: Partial<DATA_TYPE> | null;
 };
-declare type InfiniteTableGroupColumnGetterOptions<T> = {
-    groupIndexForColumn?: number;
-    groupByForColumn?: DataSourceGroupBy<T>;
-    groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
-    groupCount: number;
-    groupBy: DataSourceGroupBy<T>[];
-    pivotBy?: DataSourcePivotBy<T>[];
+declare type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParam<DATA_TYPE> & {};
+declare type InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableGroupColumnRenderParams<DATA_TYPE, COL_TYPE> & {
+    collapsed: boolean;
+    groupIcon: Renderable;
 };
-declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
+declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<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;
     column: COL_TYPE;
-    groupBy: DataSourcePropGroupBy<T>;
-    pivotBy: DataSourcePropPivotBy<T>;
 };
-declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
-declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
+declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<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>;
-    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>;
+    valueGetter?: InfiniteTableColumnValueGetter<T>;
+}, 'render' | 'renderValue' | 'field' | 'valueGetter'>;
+declare type InfiniteTableColumnStyleFnParams<T> = {
+    value: Renderable;
+    column: InfiniteTableColumn<T>;
+} & InfiniteTableRowInfoDataDiscriminator<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> = InfiniteTableRowInfoDataDiscriminator<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>;
+    defaultWidth?: number;
+    defaultFlex?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    components?: {
+        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+    };
 };
-declare type ScrollStopInfo = {
-    scrollTop: number;
-    firstVisibleRowIndex: number;
-    lastVisibleRowIndex: number;
+/**
+ * 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;
 };
-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 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 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 +1421,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 };
+export { ColumnTypeWithInherit, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropLivePaginationCursor, DataSourcePropPivotBy, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, 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, LazyRowInfoGroup, Scrollbars, debounce, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };