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

package/index.d.ts

@@ -6,32 +6,6 @@ declare function debounce(fn: Function, { wait }: {
     wait: number;
 }): (...args: any[]) => void;
 
-declare type Renderable = React$1.ReactNode | JSX.Element;
-
-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;
@@ -47,6 +21,9 @@ declare class DeepMap<KeyType, ValueType> {
     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;
@@ -69,60 +46,29 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
-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;
-}
-
-interface ScrollPosition {
-    scrollTop: number;
-    scrollLeft: number;
-}
-declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
-
-interface Size {
-    width: number;
-    height: number;
-}
-
-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 class ScrollListener {
-    private scrollPosition;
-    private onScrollFns;
-    getScrollPosition: () => ScrollPosition;
-    onScroll: (fn: OnScrollFn) => () => void;
-    setScrollPosition: (scrollPosition: ScrollPosition) => void;
-    private notifyScrollChange;
-    destroy: () => void;
-}
-
-declare type NonUndefined<T> = T extends undefined ? never : T;
+declare type 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;
@@ -140,6 +86,23 @@ declare type ComponentInterceptedActions<T_STATE> = {
 };
 declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
 
+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;
+};
+
 interface LogFn {
     (...args: any[]): LogFn;
     extend: (channelName: string) => LogFn;
@@ -150,6 +113,19 @@ 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 VoidFn = () => void;
+
 declare type FixedPosition = false | 'start' | 'end';
 declare type SpanFunction = ({ rowIndex, colIndex, }: {
     rowIndex: number;
@@ -398,6 +374,28 @@ declare class MatrixBrain extends Logger {
     destroy: () => void;
 }
 
+declare type Renderable = React$1.ReactNode | JSX.Element;
+
+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 class ScrollListener {
+    private scrollPosition;
+    private onScrollFns;
+    getScrollPosition: () => ScrollPosition;
+    onScroll: (fn: OnScrollFn) => () => void;
+    setScrollPosition: (scrollPosition: ScrollPosition) => void;
+    private notifyScrollChange;
+    destroy: () => void;
+}
+
+declare type NonUndefined<T> = T extends undefined ? never : T;
+
 interface InfiniteTableSetupState<T> {
     propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
     columnsWhenInlineGroupRenderStrategy?: Map<string, InfiniteTableColumn<T>>;
@@ -496,63 +494,10 @@ declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<
 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;
-};
-
-interface InfiniteTableComputedValues<T> {
-    scrollbars: {
-        vertical: boolean;
-        horizontal: boolean;
-    };
-    rowspan?: MatrixBrainOptions['rowspan'];
-    computedPinnedStartOverflow: boolean;
-    computedPinnedEndOverflow: boolean;
-    computedPinnedStartColumns: InfiniteTableComputedColumn<T>[];
-    computedPinnedEndColumns: InfiniteTableComputedColumn<T>[];
-    computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
-    computedVisibleColumns: InfiniteTableComputedColumn<T>[];
-    computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
-    computedColumnVisibility: InfiniteTablePropColumnVisibility;
-    computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
-    computedPinnedStartColumnsWidth: number;
-    computedPinnedStartWidth: number;
-    computedPinnedEndColumnsWidth: number;
-    computedPinnedEndWidth: number;
-    computedUnpinnedColumnsWidth: number;
-    computedUnpinnedOffset: number;
-    computedPinnedEndOffset: number;
-    computedRemainingSpace: number;
-    toggleGroupRow: (groupKeys: any[]) => void;
-    columnSize: (colIndex: number) => number;
-}
-
-interface InfiniteTableContextValue<T> {
-    componentState: InfiniteTableState<T>;
-    componentActions: InfiniteTableActions<T>;
-    computed: InfiniteTableComputedValues<T>;
-    getComputed: () => InfiniteTableComputedValues<T>;
-    getState: () => InfiniteTableState<T>;
-}
-
 declare type LoadMaskProps = {
     visible: boolean;
     children: Renderable;
 };
-
 declare type InfiniteTablePropColumnOrderNormalized = string[];
 declare type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
 declare type InfiniteTablePropColumnVisibility = Record<string, false>;
@@ -562,14 +507,7 @@ declare type InfiniteTablePropColumnPinningRecord = Record<string, true | 'start
 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>;
-});
+} & 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>;
@@ -755,101 +693,40 @@ declare type Scrollbars = {
     horizontal: boolean;
 };
 
-declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
-    id: string;
-};
-declare type AggregationReducerResult<AggregationResultType extends any = any> = {
-    value: AggregationResultType;
-    id: string;
-};
-declare type InfiniteTableRowInfoNormalType<DataType> = {
-    data: DataType;
-    isGroupRow: false;
-};
-declare type InfiniteTableRowInfoGroupType<DataType> = {
-    data: Partial<DataType> | null;
-    isGroupRow: true;
-};
-declare type InfiniteTableRowInfoNormal<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoNormalType<T>;
-declare type InfiniteTableRowInfoGroup<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoGroupType<T>;
-declare type InfiniteTableRowInfo<T> = InfiniteTableRowInfoNormal<T> | InfiniteTableRowInfoGroup<T>;
-declare type InfiniteTableRowInfoBase<T> = {
-    id: any;
-    value?: any;
-    groupData?: T[];
-    collapsed: boolean;
-    collapsedChildrenCount?: number;
-    collapsedGroupsCount?: number;
-    groupNesting?: number;
-    groupKeys?: any[];
-    flatRowInfoList?: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
-    parents?: InfiniteTableEnhancedGroupInfo<T>[];
-    indexInParentGroups?: number[];
-    indexInGroup: number;
-    indexInAll: number;
-    groupCount?: number;
-    groupBy?: (keyof T)[];
-    rootGroupBy?: (keyof T)[];
-    pivotValuesMap?: PivotValuesDeepMap<T, any>;
-    reducerResults?: Record<string, AggregationReducerResult>;
-};
-declare type InfiniteTableEnhancedGroupInfo<T> = InfiniteTableRowInfo<T> & {
-    data: Partial<T> | null;
-    groupData: T[];
-    flatRowInfoList: (InfiniteTableRowInfo<T> | InfiniteTableEnhancedGroupInfo<T>)[];
-    value: any;
-    isGroupRow: true;
-    collapsedChildrenCount: number;
-    collapsedGroupsCount: number;
-    groupNesting: number;
-    groupKeys?: any[];
-    groupCount: number;
-    groupBy: (keyof T)[];
-    rootGroupBy: (keyof T)[];
-    pivotValuesMap?: PivotValuesDeepMap<T, any>;
-};
-declare type GroupKeyType<T extends any = any> = T;
-declare type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
-declare type PivotGroupValueType<DataType, KeyType> = {
-    reducerResults: PivotReducerResults<KeyType>;
-    items: DataType[];
-};
-declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
-declare type DeepMapGroupValueType<DataType, KeyType> = {
-    items: DataType[];
-    commonData?: Partial<DataType>;
-    reducerResults: Record<string, AggregationReducerResult>;
-    pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
-};
-declare type GroupBy<DataType, KeyType> = {
-    field: keyof DataType;
-    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
-    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
-};
-declare type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
-    column?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<DataType>>> | (({ column, }: {
-        column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
-    }) => Partial<InfiniteTablePivotColumn<DataType>>);
-    columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
-        columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
-    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnGroup<DataType>>>);
-};
-declare type GroupParams<DataType, KeyType> = {
-    groupBy: GroupBy<DataType, KeyType>[];
-    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
-    pivot?: PivotBy<DataType, KeyType>[];
-    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
-};
-declare type DataGroupResult<DataType, KeyType extends any> = {
-    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
-    groupParams: GroupParams<DataType, KeyType>;
-    initialData: DataType[];
-    reducerResults?: Record<string, AggregationReducerResult>;
-    topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
-    pivot?: PivotBy<DataType, KeyType>[];
-};
-declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
-declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
+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;
@@ -861,6 +738,7 @@ interface DataSourceDataParams<T> {
     sortInfo?: DataSourceSortInfo<T>;
     groupBy?: DataSourcePropGroupBy<T>;
     pivotBy?: DataSourcePropPivotBy<T>;
+    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
     lazyLoadBatchSize?: number;
     lazyLoadStartIndex?: number;
     groupKeys?: any[];
@@ -879,15 +757,16 @@ 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;
+    error?: string;
     totalCount?: number;
     livePaginationCursor?: DataSourceLivePaginationCursorValue;
 };
 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>;
 };
@@ -901,7 +780,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']>;
@@ -926,18 +805,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;
@@ -955,7 +842,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;
@@ -986,8 +873,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>;
@@ -1031,9 +918,271 @@ interface DataSourceReducer<T> {
     (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
 }
 
-declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-}[Keys];
+declare 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;
+};
+declare type AggregationReducerResult<AggregationResultType extends any = any> = {
+    value: AggregationResultType;
+    id: string;
+};
+/**
+ * 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;
+    rowInfo: InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoNormal<T>;
+} | {
+    data: Partial<T> | null;
+    rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<T>;
+    isGroupRow: true;
+};
+/**
+ * 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;
+    indexInAll: number;
+};
+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;
+    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>)[];
+    error?: string;
+    reducerResults?: Record<string, AggregationReducerResult>;
+    /**
+     * The count of all leaf nodes (normal rows) that are inside this group.
+     * This count is the same as the length of the groupData array property.
+     */
+    groupCount: number;
+    /**
+     * The array of all leaf nodes (normal rows) that are inside this group.
+     */
+    groupData: T[];
+    /**
+     * The count of all leaf nodes (normal rows) inside the group that are not being visible
+     * due to collapsing (either the current row is collapsed or any of its children)
+     */
+    collapsedChildrenCount: number;
+    collapsedGroupsCount: number;
+    /**
+     * The count of the direct children of the current group. Direct children can be either normal rows or groups.
+     */
+    directChildrenCount: number;
+    directChildrenLoadedCount: number;
+    /**
+     *
+     * A DeepMap of pivot values.
+     *
+     * For each pivot reducer result, it contains all the items that make up the pivot value.
+     *
+     */
+    pivotValuesMap?: PivotValuesDeepMap<T, any>;
+    /**
+     * For non-lazy grouping, this is always true.
+     * For lazy/batched grouping, this is true if the group has been expanded at least once (and if the remote call has been configured with cache: true),
+     * since if the remote call is not cached, collapsing the row group should lose all the data that was loaded for it, and it's as if it was never loaded, so in that case, childrenAvailable is false.
+     *
+     * NOTE: if this is true, it doesn't mean that all the children have been loaded, it only means that some children have been loaded and are available
+     *
+     * Use directChildrenCount and directChildrenLoadedCount to know if all the children have been loaded or not.
+     */
+    childrenAvailable: boolean;
+    /**
+     * Boolean flag that will be true while lazy loading direct children of the current row group.
+     *
+     * NOTE: with batched loading, if the user is no longer scrolling, after everything
+     * in the viewport has loaded (and thus for example a certain row group had childrenLoading: true)
+     * if no new batches are being loaded, childrenLoading will be false again, even though
+     * the current row group still has children that are not loaded yet.
+     * Use directChildrenLoadedCount and directChildrenCount to know if all the children have been loaded or not.
+     */
+    childrenLoading: boolean;
+} & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
+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)[];
+    /**
+     * 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>>;
+declare type PivotGroupValueType<DataType, KeyType> = {
+    reducerResults: PivotReducerResults<KeyType>;
+    items: DataType[];
+};
+declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
+declare type DeepMapGroupValueType<DataType, KeyType> = {
+    /**
+     * 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>>;
+};
+declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+    column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
+};
+declare type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
+    column?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<DataType>>> | (({ column, }: {
+        column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
+    }) => Partial<InfiniteTablePivotColumn<DataType>>);
+    columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
+        columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
+    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnGroup<DataType>>>);
+};
+declare type GroupParams<DataType, KeyType> = {
+    groupBy: GroupBy<DataType, KeyType>[];
+    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
+    pivot?: PivotBy<DataType, KeyType>[];
+    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
+};
+declare type DataGroupResult<DataType, KeyType extends any> = {
+    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
+    groupParams: GroupParams<DataType, KeyType>;
+    initialData: DataType[];
+    reducerResults?: Record<string, AggregationReducerResult>;
+    topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
+    pivot?: PivotBy<DataType, KeyType>[];
+};
+declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
+declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
 
 declare type InfiniteTableCellProps<T> = {
     column: InfiniteTableComputedColumn<T>;
@@ -1051,6 +1200,10 @@ declare type InfiniteTableCellProps<T> = {
     cellType: 'body' | 'header';
 };
 
+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'];
@@ -1058,7 +1211,7 @@ declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTable
     column: COL_TYPE;
     columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
 };
-declare type InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
     domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
     value: string | number | Renderable;
     groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
@@ -1068,19 +1221,19 @@ declare type InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE = InfiniteTable
     toggleGroupRow: InfiniteTableToggleGroupRowFn;
     groupBy: DataSourceState<DATA_TYPE>['groupBy'];
     pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
-} & ({
-    rowInfo: InfiniteTableRowInfoNormal<DATA_TYPE>;
-    data: DATA_TYPE;
-} | {
-    rowInfo: InfiniteTableRowInfoGroup<DATA_TYPE>;
+};
+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 InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParams<DATA_TYPE> & {};
-declare type InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE> & {
+};
+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 InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParams<DATA_TYPE, COL_TYPE>;
+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;
@@ -1088,7 +1241,7 @@ declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTable
     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 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';
@@ -1107,24 +1260,12 @@ declare type InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T> =
 declare type InfiniteTableColumnStyleFnParams<T> = {
     value: Renderable;
     column: InfiniteTableColumn<T>;
-} & ({
-    data: T;
-    rowInfo: InfiniteTableRowInfoNormal<T>;
-} | {
-    data: Partial<T> | null;
-    rowInfo: InfiniteTableRowInfoGroup<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> = {
-    data: T;
-    rowInfo: InfiniteTableRowInfoNormal<T>;
-} | {
-    data: Partial<T> | null;
-    rowInfo: InfiniteTableRowInfoGroup<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;
@@ -1284,4 +1425,4 @@ declare function interceptMap<K, V>(map: Map<K, V>, fns: InterceptedMapFns<K, V>
 
 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 };