@infinite-table/infinite-react 0.0.9 → 0.1.2

package/index.d.ts

@@ -71,6 +71,7 @@ declare module "utils/DeepMap" {
         private map;
         private length;
         private revision;
+        static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
         constructor(initial?: [KeyType[], ValueType][]);
         set(keys: KeyType[] & {
             length: Omit<number, 0>;
@@ -157,7 +158,7 @@ declare module "components/hooks/useComponentState" {
     type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
         debugName?: string;
         initSetupState?: () => COMPONENT_SETUP_STATE;
-        forwardProps?: () => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE>;
+        forwardProps?: (setupState: COMPONENT_SETUP_STATE) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE>;
         allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
         interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
         mapPropsToState?: (params: {
@@ -198,7 +199,7 @@ declare module "components/DataSource/types" {
     import * as React from 'react';
     import { MultisortInfo } from "utils/multisort/index";
     import { DeepMap } from "utils/DeepMap";
-    import { AggregationReducer, DeepMapGroupValueType, GroupBy, GroupKeyType, PivotBy } from "utils/groupAndPivot/index";
+    import { DeepMapGroupValueType, GroupBy, GroupKeyType, PivotBy } from "utils/groupAndPivot/index";
     import { InfiniteTableColumn, InfiniteTableColumnGroup, InfiniteTableRowInfo, Scrollbars } from "components/InfiniteTable/index";
     import { ComponentStateActions } from "components/hooks/useComponentState";
     import { GroupRowsState } from "components/DataSource/GroupRowsState";
@@ -208,43 +209,53 @@ declare module "components/DataSource/types" {
     export interface DataSourceDataParams<T> {
         originalDataArray: T[];
         sortInfo?: DataSourceSortInfo<T>;
-        groupRowsBy?: DataSourcePropGroupRowsBy<T>;
+        groupBy?: DataSourcePropGroupBy<T>;
         pivotBy?: DataSourcePropPivotBy<T>;
         livePaginationCursor?: DataSourceLivePaginationCursorValue;
+        changes?: DataSourceDataParamsChanges<T>;
     }
+    export type DataSourceDataParamsChanges<T> = Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>;
     export type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
         field?: keyof T;
         id?: string;
     };
-    export type DataSourceGroupRowsBy<T> = GroupBy<T, any>;
+    export type DataSourceGroupBy<T> = GroupBy<T, any>;
     export type DataSourcePivotBy<T> = PivotBy<T, any>;
     export type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
     export type DataSourceRemoteData<T> = {
         data: T[];
         livePaginationCursor?: DataSourceLivePaginationCursorValue;
     };
-    export type DataSourceData<T> = T[] | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
+    export type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
     export type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
     export type DataSourceExpandedAndCollapsedGroupRows<KeyType> = {
         expandedRows: DataSourceGroupRowsList<KeyType>;
         collapsedRows: DataSourceGroupRowsList<KeyType>;
     };
-    export type DataSourcePropGroupRowsBy<T> = DataSourceGroupRowsBy<T>[];
+    export type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
     export type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
     export interface DataSourceMappedState<T> {
+        aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
         livePagination: DataSourceProps<T>['livePagination'];
-        livePaginationCursor: DataSourceProps<T>['livePaginationCursor'];
-        remoteCount: DataSourceProps<T>['remoteCount'];
         onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
         data: DataSourceProps<T>['data'];
         primaryKey: DataSourceProps<T>['primaryKey'];
-        groupRowsBy: NonUndefined<DataSourceProps<T>['groupRowsBy']>;
+        groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
         groupRowsState: NonUndefined<DataSourceProps<T>['groupRowsState']>;
         pivotBy: DataSourceProps<T>['pivotBy'];
         loading: NonUndefined<DataSourceProps<T>['loading']>;
         sortInfo: DataSourceSingleSortInfo<T>[] | null;
     }
+    export type DataSourceAggregationReducer<T, AggregationResultType> = {
+        field?: keyof T;
+        initialValue: AggregationResultType;
+        getter?: (data: T) => any;
+        reducer: (accumulator: any, value: any, data: T) => AggregationResultType | any;
+        done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+    };
     export interface DataSourceSetupState<T> {
+        propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
+        showSeparatePivotColumnForSingleAggregation: boolean;
         dataParams?: DataSourceDataParams<T>;
         notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
         originalDataArray: T[];
@@ -259,17 +270,16 @@ declare module "components/DataSource/types" {
         groupedAt: number;
         sortedAt: number;
         generateGroupRows: boolean;
-        aggregationReducers?: AggregationReducer<T, any>[];
         postSortDataArray?: T[];
         postGroupDataArray?: InfiniteTableRowInfo<T>[];
         pivotColumns?: Map<string, InfiniteTableColumn<T>>;
         pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
     }
+    export type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
     export interface DataSourceProps<T> {
         children: React.ReactNode | ((contextData: DataSourceState<T>) => React.ReactNode);
         primaryKey: keyof T;
         fields?: (keyof T)[];
-        remoteCount?: number;
         data: DataSourceData<T>;
         loading?: boolean;
         defaultLoading?: boolean;
@@ -277,9 +287,11 @@ declare module "components/DataSource/types" {
         pivotBy?: DataSourcePropPivotBy<T>;
         defaultPivotBy?: DataSourcePropPivotBy<T>;
         onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
-        groupRowsBy?: DataSourcePropGroupRowsBy<T>;
-        defaultGroupRowsBy?: DataSourcePropGroupRowsBy<T>;
-        onGroupRowsByChange?: (groupBy: DataSourcePropGroupRowsBy<T>) => void;
+        aggregationReducers?: DataSourcePropAggregationReducers<T>;
+        defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
+        groupBy?: DataSourcePropGroupBy<T>;
+        defaultGroupBy?: DataSourcePropGroupBy<T>;
+        onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
         groupRowsState?: GroupRowsState;
         defaultGroupRowsState?: GroupRowsState;
         onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
@@ -288,14 +300,23 @@ declare module "components/DataSource/types" {
         onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
         onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
         livePagination?: boolean;
-        livePaginationCursor?: DataSourceLivePaginationCursorValue;
+        livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
+        onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
     }
-    export type DataSourceLivePaginationCursorValue = string | number;
+    export type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
+    export type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
+    export type DataSourceLivePaginationCursorParams<T> = {
+        array: T[];
+        lastItem: T | Partial<T> | null;
+        length: number;
+    };
+    export type DataSourceLivePaginationCursorValue = string | number | null;
     export interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
     }
     export interface DataSourceDerivedState<_T> {
         multiSort: boolean;
         controlledSort: boolean;
+        livePaginationCursor?: DataSourceLivePaginationCursorValue;
     }
     export type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
     export interface DataSourceContextValue<T> {
@@ -331,14 +352,14 @@ declare module "components/hooks/useEffectWithChanges" {
     export function useEffectWithObject(fn: EffectCallback, deps: Record<string, any>): void;
 }
 declare module "components/DataSource/privateHooks/useLoadData" {
-    import { DataSourceDataParams, DataSourceState } from "components/DataSource/types";
-    export function buildDataSourceDataParams<T>(componentState: DataSourceState<T>): DataSourceDataParams<T>;
+    import { DataSourceDataParams, DataSourceState, DataSourceDataParamsChanges } from "components/DataSource/types";
+    export function buildDataSourceDataParams<T>(componentState: DataSourceState<T>, changes?: DataSourceDataParamsChanges<T>): DataSourceDataParams<T>;
     export function useLoadData<T>(): void;
     export function useLivePagination<T>(): void;
 }
 declare module "components/DataSource/state/normalizeSortInfo" {
     import { DataSourceSingleSortInfo, DataSourceSortInfo } from "components/DataSource/types";
-    export const normalizeSortInfo: <T>(sortInfo?: DataSourceSortInfo<T> | undefined) => DataSourceSingleSortInfo<T>[];
+    export const normalizeSortInfo: <T>(initialSortInfo?: DataSourceSortInfo<T> | undefined, weakMap?: WeakMap<any, any> | undefined) => DataSourceSingleSortInfo<T>[];
 }
 declare module "components/utils/buildSubscriptionCallback" {
     import { SubscriptionCallback } from "components/types/SubscriptionCallback";
@@ -356,18 +377,17 @@ declare module "components/DataSource/state/getInitialState" {
     import { ComponentInterceptedActions, ForwardPropsToStateFnResult } from "components/hooks/useComponentState";
     import { DataSourceDataParams } from "components/DataSource/index";
     export function initSetupState<T>(): DataSourceSetupState<T>;
-    export const forwardProps: <T>() => Partial<{
+    export const forwardProps: <T>(setupState: DataSourceSetupState<T>) => Partial<{
         data: 1 | ((value: import("components/DataSource").DataSourceData<T>) => import("components/DataSource").DataSourceData<T>);
         loading: 1 | ((value: boolean | undefined) => boolean);
+        sortInfo: 1 | ((value: import("components/DataSource").DataSourceSortInfo<T> | undefined) => import("components/DataSource").DataSourceSingleSortInfo<T>[] | null);
+        groupBy: 1 | ((value: import("components/DataSource").DataSourcePropGroupBy<T> | undefined) => import("components/DataSource").DataSourcePropGroupBy<T>);
+        pivotBy: 1 | ((value: import("components/DataSource").DataSourcePropPivotBy<T> | undefined) => import("components/DataSource").DataSourcePropPivotBy<T> | undefined);
+        aggregationReducers: 1 | ((value: import("components/DataSource").DataSourcePropAggregationReducers<T> | undefined) => import("components/DataSource").DataSourcePropAggregationReducers<T> | undefined);
         livePagination: 1 | ((value: boolean | undefined) => boolean | undefined);
-        livePaginationCursor: 1 | ((value: import("components/DataSource").DataSourceLivePaginationCursorValue | undefined) => import("components/DataSource").DataSourceLivePaginationCursorValue | undefined);
-        remoteCount: 1 | ((value: number | undefined) => number | undefined);
         onDataParamsChange: 1 | ((value: ((dataParamsChange: DataSourceDataParams<T>) => void) | undefined) => ((dataParamsChange: DataSourceDataParams<T>) => void) | undefined);
         primaryKey: 1 | ((value: keyof T) => keyof T);
-        groupRowsBy: 1 | ((value: import("components/DataSource").DataSourcePropGroupRowsBy<T> | undefined) => import("components/DataSource").DataSourcePropGroupRowsBy<T>);
         groupRowsState: 1 | ((value: GroupRowsState<any> | undefined) => GroupRowsState<any>);
-        pivotBy: 1 | ((value: import("components/DataSource").DataSourcePropPivotBy<T> | undefined) => import("components/DataSource").DataSourcePropPivotBy<T> | undefined);
-        sortInfo: 1 | ((value: import("components/DataSource").DataSourceSortInfo<T> | undefined) => import("components/DataSource").DataSourceSingleSortInfo<T>[] | null);
     }>;
     export function mapPropsToState<T extends any>(params: {
         props: DataSourceProps<T>;
@@ -381,6 +401,7 @@ declare module "components/types/Renderable" {
 }
 declare module "components/InfiniteTable/types/Utility" {
     export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+    export type MapOrRecord<K extends string, V> = Map<K, V> | Record<K, V>;
     export type RequireOnlyOneProperty<T, Keys extends keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
         [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
     }[Keys];
@@ -400,26 +421,30 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
     import type { Renderable } from "components/types/Renderable";
     import type { DataSourcePivotBy, DataSourceSingleSortInfo, DataSourceState } from "components/DataSource/types";
     import type { DiscriminatedUnion, RequireAtLeastOne } from "components/InfiniteTable/types/Utility";
-    import type { InfiniteTableRowInfo } from "components/InfiniteTable/types/index";
+    import type { InfiniteTableColumnGroup, InfiniteTableRowInfo } from "components/InfiniteTable/types/index";
     import { CSSProperties } from 'react';
-    import { PivotBy } from "utils/groupAndPivot/index";
+    import { AggregationReducer, InfiniteTableRowInfoGroup, InfiniteTableRowInfoNormal, PivotBy } from "utils/groupAndPivot/index";
     export type { DiscriminatedUnion, RequireAtLeastOne };
     export type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
-    export interface InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> {
+    export type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
         value: string | number | Renderable;
-        data: DATA_TYPE | null;
-        rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
         groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
         rowIndex: number;
         column: COL_TYPE;
         toggleCurrentGroupRow: () => void;
         toggleGroupRow: InfiniteTableToggleGroupRowFn;
-        groupRowsBy: DataSourceState<DATA_TYPE>['groupRowsBy'];
-    }
+        groupBy: DataSourceState<DATA_TYPE>['groupBy'];
+    } & ({
+        rowInfo: InfiniteTableRowInfoNormal<DATA_TYPE>;
+        data: DATA_TYPE;
+    } | {
+        rowInfo: InfiniteTableRowInfoGroup<DATA_TYPE>;
+        data: Partial<DATA_TYPE> | null;
+    });
     export type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
     export type InfiniteTableColumnRowspanFnParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-        data: DATA_TYPE | null;
         rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
+        data: DATA_TYPE | Partial<DATA_TYPE> | null;
         groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
         dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
         rowIndex: number;
@@ -430,7 +455,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         columnSortInfo: DataSourceSingleSortInfo<T> | null | undefined;
     }
     export type InfiniteTableColumnPinned = 'start' | 'end' | false;
-    export type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupRowsBy, }: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
+    export type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupBy, }: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
     export type InfiniteTableColumnRenderValueFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE>;
     export type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderRenderParams<T>) => Renderable;
     export type InfiniteTableColumnWithField<T> = {
@@ -453,19 +478,25 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         valueGetter?: InfiniteTableColumnValueGetter<T>;
     }, 'render' | 'renderValue' | 'field' | 'valueGetter'>;
     export type InfiniteTableColumnStyleFnParams<T> = {
-        data: T | null;
         value: Renderable;
-        rowInfo: InfiniteTableRowInfo<T>;
         column: InfiniteTableColumn<T>;
-    };
+    } & ({
+        data: T;
+        rowInfo: InfiniteTableRowInfoNormal<T>;
+    } | {
+        data: Partial<T> | null;
+        rowInfo: InfiniteTableRowInfoGroup<T>;
+    });
     export type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
     export type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
     export type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
     export type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
     export type InfiniteTableColumnValueGetterParams<T> = {
-        data: T | null;
-        rowInfo: InfiniteTableRowInfo<T>;
-        groupRowInfo: InfiniteTableRowInfo<T> | null;
+        data: T;
+        rowInfo: InfiniteTableRowInfoNormal<T>;
+    } | {
+        data: Partial<T> | null;
+        rowInfo: InfiniteTableRowInfoGroup<T>;
     };
     export type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = Renderable> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
     export type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanFnParams<T>) => number;
@@ -475,6 +506,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         draggable?: boolean;
         resizable?: boolean;
         comparer?: InfiniteTableColumnComparer<T>;
+        hiddenWhenGrouped?: boolean;
         align?: InfiniteTableColumnAlign;
         verticalAlign?: InfiniteTableColumnVerticalAlign;
         columnGroup?: string;
@@ -487,27 +519,33 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         className?: InfiniteTableColumnClassName<T>;
         rowspan?: InfiniteTableColumnRowspanFn<T>;
         valueGetter?: InfiniteTableColumnValueGetter<T>;
+        defaultWidth?: number;
+        defaultFlex?: number;
     };
     export type InfiniteTableColumn<T> = {} & InfiniteTableBaseColumn<T> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T>;
     export type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
-        groupByField?: string | string[];
+        groupByField: string | string[];
         id?: string;
     };
-    export type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & {
-        pivotBy?: DataSourcePivotBy<T>[];
-        pivotColumn?: true;
-        pivotTotalColumn?: true;
-        pivotGroupKeys?: any[];
-        pivotByForColumn?: DataSourcePivotBy<T>;
-        pivotIndexForColumn?: number;
-        pivotGroupKeyForColumn?: any;
+    export type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & Partial<InfiniteTablePivotFinalColumn<T, any>>;
+    export type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
+        pivotBy: DataSourcePivotBy<DataType>[];
+        pivotTotalColumnGroup?: true;
+        pivotGroupKeys: KeyType[];
+        pivotByAtIndex: PivotBy<DataType, KeyType>;
+        pivotGroupKey: KeyType;
+        pivotIndex: number;
     };
-    export type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTablePivotColumn<DataType> & {
+    export type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
         pivotBy: DataSourcePivotBy<DataType>[];
+        pivotColumn: true;
+        pivotTotalColumn: boolean;
+        pivotAggregator: AggregationReducer<DataType, any>;
+        pivotAggregatorIndex: number;
         pivotGroupKeys: KeyType[];
-        pivotByForColumn: PivotBy<DataType, KeyType>;
-        pivotIndexForColumn: number;
-        pivotGroupKeyForColumn: KeyType;
+        pivotByAtIndex: PivotBy<DataType, KeyType>;
+        pivotIndex: number;
+        pivotGroupKey: KeyType;
     };
     type InfiniteTableComputedColumnBase<T> = {
         computedWidth: number;
@@ -531,10 +569,11 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
         toggleSort: () => void;
         id: string;
     };
-    export type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & InfiniteTablePivotColumn<T> & InfiniteTableGeneratedGroupColumn<T>;
+    export type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
+    export type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 }
 declare module "utils/groupAndPivot/getPivotColumnsAndColumnGroups" {
-    import type { DataSourcePivotBy } from "components/DataSource/index";
+    import type { DataSourceAggregationReducer, DataSourcePivotBy } from "components/DataSource/index";
     import type { InfiniteTablePropColumnGroups, InfiniteTablePropColumnsMap } from "components/InfiniteTable/index";
     import type { InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
     import type { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
@@ -543,7 +582,13 @@ declare module "utils/groupAndPivot/getPivotColumnsAndColumnGroups" {
         columns: InfiniteTablePropColumnsMap<DataType, InfiniteTablePivotColumn<DataType>>;
         columnGroups: InfiniteTablePropColumnGroups;
     };
-    export function getPivotColumnsAndColumnGroups<DataType, KeyType = any>(deepMap: DeepMap<KeyType, boolean>, pivotBy: DataSourcePivotBy<DataType>[], pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition): ComputedColumnsAndGroups<DataType>;
+    export function getPivotColumnsAndColumnGroups<DataType, KeyType = any>({ deepMap, pivotBy, pivotTotalColumnPosition, reducers, showSeparatePivotColumnForSingleAggregation, }: {
+        deepMap: DeepMap<KeyType, boolean>;
+        pivotBy: DataSourcePivotBy<DataType>[];
+        pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
+        reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
+        showSeparatePivotColumnForSingleAggregation?: boolean;
+    }): ComputedColumnsAndGroups<DataType>;
 }
 declare module "components/DataSource/state/reducer" {
     import type { DataSourceState, DataSourceDerivedState } from "components/DataSource/types";
@@ -587,22 +632,33 @@ declare module "components/DataSource/GroupRowsState" {
     }
 }
 declare module "utils/groupAndPivot/index" {
+    import { DataSourceAggregationReducer } from "@infinite-table/infinite-react";
     import { GroupRowsState } from "components/DataSource/GroupRowsState";
-    import { InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
-    import { InfiniteTableGroupColumnBase } from "components/InfiniteTable/types/InfiniteTableProps";
+    import { InfiniteTableColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn, InfiniteTablePivotFinalColumnGroup } from "components/InfiniteTable/types/InfiniteTableColumn";
+    import { InfiniteTableColumnGroup, InfiniteTableGroupColumnBase } from "components/InfiniteTable/types/InfiniteTableProps";
     import { DeepMap } from "utils/DeepMap";
-    export type AggregationReducer<T, AggregationResultType> = {
-        initialValue: AggregationResultType;
-        getter: (data: T) => any;
-        reducer: (accumulator: any, value: any, data: T) => AggregationResultType | any;
-        done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+    export type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
+        id: string;
+    };
+    export type AggregationReducerResult<AggregationResultType extends any = any> = {
+        value: AggregationResultType;
+        id: string;
     };
-    export interface InfiniteTableRowInfo<T> {
+    export type InfiniteTableRowInfoNormalType<DataType> = {
+        data: DataType;
+        isGroupRow: false;
+    };
+    export type InfiniteTableRowInfoGroupType<DataType> = {
+        data: Partial<DataType> | null;
+        isGroupRow: true;
+    };
+    export type InfiniteTableRowInfoNormal<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoNormalType<T>;
+    export type InfiniteTableRowInfoGroup<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoGroupType<T>;
+    export type InfiniteTableRowInfo<T> = InfiniteTableRowInfoNormal<T> | InfiniteTableRowInfoGroup<T>;
+    export type InfiniteTableRowInfoBase<T> = {
         id: any;
-        data: T | null;
-        groupData?: T[];
         value?: any;
-        isGroupRow?: boolean;
+        groupData?: T[];
         collapsed: boolean;
         collapsedChildrenCount?: number;
         collapsedGroupsCount?: number;
@@ -615,10 +671,10 @@ declare module "utils/groupAndPivot/index" {
         groupCount?: number;
         groupBy?: (keyof T)[];
         pivotValuesMap?: PivotValuesDeepMap<T, any>;
-        reducerResults?: any[];
-    }
-    export interface InfiniteTableEnhancedGroupInfo<T> extends InfiniteTableRowInfo<T> {
-        data: null;
+        reducerResults?: Record<string, AggregationReducerResult>;
+    };
+    export type InfiniteTableEnhancedGroupInfo<T> = InfiniteTableRowInfo<T> & {
+        data: Partial<T> | null;
         groupData: T[];
         value: any;
         isGroupRow: true;
@@ -629,9 +685,9 @@ declare module "utils/groupAndPivot/index" {
         groupCount: number;
         groupBy: (keyof T)[];
         pivotValuesMap?: PivotValuesDeepMap<T, any>;
-    }
+    };
     export type GroupKeyType<T extends any = any> = T;
-    type PivotReducerResults<T = any> = T[];
+    type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
     type PivotGroupValueType<DataType, KeyType> = {
         reducerResults: PivotReducerResults<KeyType>;
         items: DataType[];
@@ -639,7 +695,7 @@ declare module "utils/groupAndPivot/index" {
     export type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
     export type DeepMapGroupValueType<DataType, KeyType> = {
         items: DataType[];
-        reducerResults: any[];
+        reducerResults: Record<string, AggregationReducerResult>;
         pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
     };
     export type GroupBy<DataType, KeyType> = {
@@ -648,21 +704,24 @@ declare module "utils/groupAndPivot/index" {
         column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
     };
     export type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
-        column?: InfiniteTablePivotColumn<DataType> | (({ column, }: {
+        column?: InfiniteTableColumn<DataType> | (({ column, }: {
             column: InfiniteTablePivotFinalColumn<DataType, KeyType>;
         }) => Partial<InfiniteTablePivotColumn<DataType>>);
+        columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
+            columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
+        }) => Partial<InfiniteTablePivotFinalColumnGroup<DataType>>);
     };
     type GroupParams<DataType, KeyType> = {
         groupBy: GroupBy<DataType, KeyType>[];
         defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
         pivot?: PivotBy<DataType, KeyType>[];
-        reducers?: AggregationReducer<DataType, any>[];
+        reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
     };
     export type DataGroupResult<DataType, KeyType extends any> = {
         deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
         groupParams: GroupParams<DataType, KeyType>;
         initialData: DataType[];
-        reducerResults?: any[];
+        reducerResults?: Record<string, AggregationReducerResult>;
         topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
         pivot?: PivotBy<DataType, KeyType>[];
     };
@@ -672,6 +731,7 @@ declare module "utils/groupAndPivot/index" {
         groupResult: DataGroupResult<DataType, KeyType>;
         toPrimaryKey: (data: DataType) => any;
         groupRowsState?: GroupRowsState;
+        reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
         generateGroupRows: boolean;
     };
     export function enhancedFlatten<DataType, KeyType = any>(param: EnhancedFlattenParam<DataType, KeyType>): {
@@ -859,35 +919,39 @@ declare module "components/InfiniteTable/components/LoadMask" {
 declare module "components/InfiniteTable/types/InfiniteTableProps" {
     import * as React from 'react';
     import { InfiniteTableState } from "components/InfiniteTable/types/index";
-    import { AggregationReducer, InfiniteTableRowInfo } from "utils/groupAndPivot/index";
-    import { DataSourceGroupRowsBy, DataSourcePropGroupRowsBy, DataSourcePropPivotBy, DataSourceState } from "components/DataSource/index";
+    import { AggregationReducer, InfiniteTableRowInfoGroup, InfiniteTableRowInfoNormal } from "utils/groupAndPivot/index";
+    import { DataSourceGroupBy, DataSourcePropGroupBy, DataSourcePropPivotBy, DataSourceState } from "components/DataSource/index";
     import { Renderable } from "components/types/Renderable";
     import { LoadMaskProps } from "components/InfiniteTable/components/LoadMask";
-    import type { InfiniteTableBaseColumn, InfiniteTableColumn, InfiniteTableColumnRenderFunction, InfiniteTableComputedColumn, InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
+    import type { InfiniteTableBaseColumn, InfiniteTableColumn, InfiniteTableColumnPinned, InfiniteTableColumnRenderFunction, InfiniteTableComputedColumn, InfiniteTableComputedPivotFinalColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
     import { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
     export type InfiniteTablePropColumnOrderNormalized = string[];
     export type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
     export type InfiniteTablePropColumnVisibility = Map<string, false>;
     export type InfiniteTablePropColumnPinning = Map<string, true | 'start' | 'end'>;
     export type InfiniteTableRowStyleFnParams<T> = {
-        data: T | null;
-        rowInfo: InfiniteTableRowInfo<T>;
         rowIndex: number;
-        groupRowsBy?: (keyof T)[];
-    };
+        groupBy?: (keyof T)[];
+    } & ({
+        data: T;
+        rowInfo: InfiniteTableRowInfoNormal<T>;
+    } | {
+        data: Partial<T> | null;
+        rowInfo: InfiniteTableRowInfoGroup<T>;
+    });
     export type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React.CSSProperties;
     export type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
     export type InfiniteTablePropRowStyle<T> = React.CSSProperties | InfiniteTableRowStyleFn<T>;
     export type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
-    export type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter'> & {
+    export type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
         getter?: AggregationReducer<T, AggregationResultType>['getter'];
+        field?: keyof T;
     };
-    export type InfiniteTablePropColumnAggregations<T> = Map<string, InfiniteTableColumnAggregator<T, any>>;
     export type InfiniteTableColumnType<T> = {
         minWidth?: number;
         maxWidth?: number;
-        width?: number;
-        flex?: number;
+        defaultWidth?: number;
+        defaultFlex?: number;
         header?: InfiniteTableColumn<T>['header'];
         comparer?: InfiniteTableColumn<T>['comparer'];
         draggable?: InfiniteTableColumn<T>['draggable'];
@@ -895,8 +959,10 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         resizable?: InfiniteTableColumn<T>['resizable'];
         align?: InfiniteTableColumn<T>['align'];
         verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
+        defaultPinned?: InfiniteTableColumnPinned;
         renderValue?: InfiniteTableColumn<T>['renderValue'];
         render?: InfiniteTableColumn<T>['render'];
+        valueGetter?: InfiniteTableColumn<T>['valueGetter'];
     };
     export type InfiniteTablePropColumnTypesMap<T> = Map<'default' | string, InfiniteTableColumnType<T>>;
     export type InfiniteTablePropColumnTypes<T> = InfiniteTablePropColumnTypesMap<T> | Record<'default' | string, InfiniteTableColumnType<T>>;
@@ -911,7 +977,6 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
     export type InfiniteTableImperativeApi<T> = {
         setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
         setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
-        setColumnAggregations: (columnAggregations: InfiniteTablePropColumnAggregations<T>) => void;
         x?: T;
         getState: () => InfiniteTableState<T>;
         getDataSourceState: () => DataSourceState<T>;
@@ -949,14 +1014,14 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
     };
     export type InfiniteTableGroupColumnGetterOptions<T> = {
         groupIndexForColumn?: number;
-        groupByForColumn?: DataSourceGroupRowsBy<T>;
+        groupByForColumn?: DataSourceGroupBy<T>;
         groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
         groupCount: number;
-        groupRowsBy: DataSourceGroupRowsBy<T>[];
+        groupBy: DataSourceGroupBy<T>[];
     };
-    export type InfiniteTablePivotColumnGetterOptions<T> = {
-        column: InfiniteTablePivotColumn<T>;
-        groupRowsBy: DataSourcePropGroupRowsBy<T>;
+    export type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
+        column: COL_TYPE;
+        groupBy: DataSourcePropGroupBy<T>;
         pivotBy: DataSourcePropPivotBy<T>;
     };
     export type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
@@ -965,12 +1030,11 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         id?: string;
     };
     export type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
-        renderValue?: InfiniteTableColumnRenderFunction<T>;
-        id?: string;
+        renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
     };
     export type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
     export type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => InfiniteTableGroupColumnBase<T>;
-    export type InfiniteTablePropPivotColumn<T> = InfiniteTablePivotColumnBase<T> | ((options: InfiniteTablePivotColumnGetterOptions<T>) => InfiniteTablePivotColumnBase<T>);
+    export type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
     export type InfiniteTablePropPivotRowLabelsColumn<T> = InfiniteTablePropPivotColumn<T>;
     export type InfiniteTablePropComponents = {
         LoadMask?: React.FC<LoadMaskProps>;
@@ -981,20 +1045,18 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         loadingText?: Renderable;
         components?: InfiniteTablePropComponents;
         viewportReservedWidth?: number;
-        pivotColumn?: Partial<InfiniteTablePropPivotColumn<T>>;
-        pivotRowLabelsColumn?: Partial<InfiniteTablePropPivotRowLabelsColumn<T>>;
+        pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
+        pivotRowLabelsColumn?: InfiniteTablePropPivotRowLabelsColumn<T>;
         pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
         groupColumn?: Partial<InfiniteTablePropGroupColumn<T>>;
         groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
         hideEmptyGroupColumns?: boolean;
         columnVisibility?: InfiniteTablePropColumnVisibility;
         defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
-        columnPinning?: InfiniteTablePropColumnPinning;
         pinnedStartMaxWidth?: number;
         pinnedEndMaxWidth?: number;
+        columnPinning?: InfiniteTablePropColumnPinning;
         defaultColumnPinning?: InfiniteTablePropColumnPinning;
-        defaultColumnAggregations?: InfiniteTablePropColumnAggregations<T>;
-        columnAggregations?: InfiniteTablePropColumnAggregations<T>;
         columnSizing?: InfiniteTablePropColumnSizing;
         defaultColumnSizing?: InfiniteTablePropColumnSizing;
         pivotColumnGroups?: InfiniteTablePropColumnGroups;
@@ -1005,6 +1067,7 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
         onScrollbarsChange?: (scrollbars: Scrollbars) => void;
         onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
         columnTypes?: InfiniteTablePropColumnTypes<T>;
+        showSeparatePivotColumnForSingleAggregation?: boolean;
         rowHeight: number | string;
         rowStyle?: InfiniteTablePropRowStyle<T>;
         rowClassName?: InfiniteTablePropRowClassName<T>;
@@ -1079,9 +1142,9 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
     import { NonUndefined } from "components/types/NonUndefined";
     import { InfiniteTableColumn, InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
     import { ComponentStateActions } from "components/hooks/useComponentState";
-    import { DataSourceGroupRowsBy, DataSourceProps } from "components/DataSource/types";
-    export type GroupRowsMap<T> = Map<keyof T, {
-        groupBy: DataSourceGroupRowsBy<T>;
+    import { DataSourceGroupBy, DataSourceProps } from "components/DataSource/types";
+    export type GroupByMap<T> = Map<keyof T, {
+        groupBy: DataSourceGroupBy<T>;
         groupIndex: number;
     }>;
     export interface InfiniteTableSetupState<T> {
@@ -1128,6 +1191,7 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         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'];
@@ -1156,13 +1220,12 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
         columnPinning: NonUndefined<InfiniteTableProps<T>['columnPinning']>;
         columnSizing: InfiniteTablePropColumnSizingMap;
         columnTypes: InfiniteTablePropColumnTypesMap<T>;
-        columnAggregations: NonUndefined<InfiniteTableProps<T>['columnAggregations']>;
         columnGroups: NonUndefined<InfiniteTableProps<T>['columnGroups']>;
         collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
         pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
     }
     export interface InfiniteTableDerivedState<T> {
-        groupRowsBy: DataSourceProps<T>['groupRowsBy'];
+        groupBy: DataSourceProps<T>['groupBy'];
         computedColumns: Map<string, InfiniteTableColumn<T>>;
         virtualizeHeader: boolean;
         groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
@@ -1236,17 +1299,20 @@ declare module "components/InfiniteTable/types/index" {
     import type { InfiniteTableState } from "components/InfiniteTable/types/InfiniteTableState";
     import type { InfiniteTableAction } from "components/InfiniteTable/types/InfiniteTableAction";
     import type { InfiniteTableActionType } from "components/InfiniteTable/types/InfiniteTableActionType";
-    import type { InfiniteTableProps, InfiniteTableImperativeApi, InfiniteTablePropColumnOrder, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnAggregator, InfiniteTableColumnGroup, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnAggregations, InfiniteTablePropColumnGroups, InfiniteTablePropRowStyle, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTablePropRowClassName, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableColumnSizingOptions, Scrollbars } from "components/InfiniteTable/types/InfiniteTableProps";
+    import type { InfiniteTableProps, InfiniteTableImperativeApi, InfiniteTablePropColumnOrder, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnAggregator, InfiniteTableColumnGroup, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropRowStyle, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTablePropRowClassName, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableColumnSizingOptions, Scrollbars } from "components/InfiniteTable/types/InfiniteTableProps";
     import type { InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam } from "components/InfiniteTable/types/InfiniteTableColumn";
     import type { InfiniteTableComputedValues } from "components/InfiniteTable/types/InfiniteTableComputedValues";
     import type { InfiniteTableContextValue } from "components/InfiniteTable/types/InfiniteTableContextValue";
     import type { InfiniteTableRowInfo } from "utils/groupAndPivot/index";
-    export type { Scrollbars, InfiniteTableColumnAggregator, InfiniteTableComputedValues, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTableRowInfo, InfiniteTableGroupColumnFunction, InfiniteTablePropColumnOrder, InfiniteTablePropComponents, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnGroup, InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableContextValue, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnAggregations, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizing, InfiniteTablePropColumnSizingMap, InfiniteTableColumnSizingOptions, InfiniteTableState, InfiniteTableAction, InfiniteTableProps, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableImperativeApi, InfiniteTableActionType, InfiniteTablePropRowStyle, InfiniteTablePropRowClassName, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTableGroupColumnGetterOptions, };
+    export type { Scrollbars, InfiniteTableColumnAggregator, InfiniteTableComputedValues, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTableRowInfo, InfiniteTableGroupColumnFunction, InfiniteTablePropColumnOrder, InfiniteTablePropComponents, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnGroup, InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableContextValue, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizing, InfiniteTablePropColumnSizingMap, InfiniteTableColumnSizingOptions, InfiniteTableState, InfiniteTableAction, InfiniteTableProps, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableImperativeApi, InfiniteTableActionType, InfiniteTablePropRowStyle, InfiniteTablePropRowClassName, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTableGroupColumnGetterOptions, };
 }
 declare module "components/InfiniteTable/InfiniteTableContext" {
     import { InfiniteTableContextValue } from "components/InfiniteTable/types/InfiniteTableContextValue";
     export function getInfiniteTableContext<T>(): React.Context<InfiniteTableContextValue<T>>;
 }
+declare module "components/InfiniteTable/utils/toMap" {
+    export function toMap<K extends string, V>(mapOrObject?: Map<K, V> | Record<K, V>): Map<K, V>;
+}
 declare module "components/InfiniteTable/state/computeColumnGroupsDepths" {
     import type { InfiniteTablePropColumnGroups } from "components/InfiniteTable/types/InfiniteTableProps";
     import type { InfiniteTableColumnGroupsDepthsMap } from "components/InfiniteTable/types/InfiniteTableState";
@@ -1266,11 +1332,12 @@ declare module "components/InfiniteTable/state/getInitialState" {
     export const forwardProps: <T>() => Partial<{
         columns: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumns<T, import("components/InfiniteTable/types").InfiniteTableColumn<T>>) => import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types").InfiniteTableColumn<T>>);
         header: 1 | ((value: boolean | undefined) => boolean);
+        showSeparatePivotColumnForSingleAggregation: 1 | ((value: boolean | undefined) => boolean);
         pivotTotalColumnPosition: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableState").InfiniteTablePropPivotTotalColumnPosition | undefined) => import("components/InfiniteTable/types/InfiniteTableState").InfiniteTablePropPivotTotalColumnPosition);
         pivotColumns: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotColumn<T>> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotColumn<T>> | undefined);
         pivotColumnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined);
-        pivotColumn: 1 | ((value: Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T>> | undefined) => Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T>> | undefined);
         sortable: 1 | ((value: boolean | undefined) => boolean);
+        pivotColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T, import("components/InfiniteTable/types").InfiniteTableColumn<T> & import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotFinalColumn<T, any>> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T, import("components/InfiniteTable/types").InfiniteTableColumn<T> & import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotFinalColumn<T, any>> | undefined);
         components: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropComponents | undefined) => import("components/InfiniteTable/types").InfiniteTablePropComponents | undefined);
         scrollTopId: 1 | ((value: string | number | undefined) => string | number | undefined);
         viewportReservedWidth: 1 | ((value: number | undefined) => number | undefined);
@@ -1295,7 +1362,7 @@ declare module "components/InfiniteTable/state/getInitialState" {
         rowClassName: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined);
         pinnedStartMaxWidth: 1 | ((value: number | undefined) => number | undefined);
         pinnedEndMaxWidth: 1 | ((value: number | undefined) => number | undefined);
-        pivotRowLabelsColumn: 1 | ((value: Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T>> | undefined) => Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T>> | undefined);
+        pivotRowLabelsColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined);
         activeIndex: 1 | ((value: number | undefined) => number);
         columnMinWidth: 1 | ((value: number | undefined) => number);
         columnMaxWidth: 1 | ((value: number | undefined) => number);
@@ -1309,7 +1376,6 @@ declare module "components/InfiniteTable/state/getInitialState" {
         licenseKey: 1 | ((value: string | undefined) => string);
         columnVisibility: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility);
         columnPinning: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnPinning | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnPinning);
-        columnAggregations: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnAggregations<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnAggregations<T>);
         columnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnGroups);
         collapsedColumnGroups: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups);
         columnSizing: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnSizing | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnSizingMap);
@@ -1532,13 +1598,6 @@ declare module "components/InfiniteTable/hooks/useComputedVisibleColumns" {
     };
     export const useComputedVisibleColumns: <T extends unknown>({ columns, bodySize, columnMinWidth, columnMaxWidth, columnDefaultWidth, sortable, draggableColumns, sortInfo, multiSort, setSortInfo, columnOrder, columnPinning, columnTypes, pinnedEndMaxWidth, pinnedStartMaxWidth, viewportReservedWidth, columnVisibility, columnVisibilityAssumeVisible, columnSizing, }: UseComputedVisibleColumnsParam<T>) => UseComputedVisibleColumnsResult<T>;
 }
-declare module "components/DataSource/publicHooks/useDataSourceActions" {
-    import { DataSourceComponentActions } from "components/DataSource/types";
-    export default function useDataSourceActions<T>(): DataSourceComponentActions<T>;
-}
-declare module "components/InfiniteTable/hooks/useColumnAggregations" {
-    export function useColumnAggregations<T>(): void;
-}
 declare module "components/InfiniteTable/hooks/useColumnGroups" {
     export function useColumnGroups<T>(): void;
 }
@@ -1546,6 +1605,15 @@ declare module "utils/join" {
     const join: (...args: (string | number | void | null)[]) => string;
     export { join };
 }
+declare module "components/InfiniteTable/components/icons/ExpanderIcon.css" {
+    export const ExpanderIconCls: string;
+    export const ExpanderIconClsVariants: import("@vanilla-extract/recipes/dist/declarations/src/types").RuntimeFn<{
+        expanded: {
+            true: string;
+            false: {};
+        };
+    }>;
+}
 declare module "components/InfiniteTable/components/icons/ExpanderIcon" {
     import * as React from 'react';
     type ExpanderIconProps = {
@@ -1590,7 +1658,7 @@ declare module "components/InfiniteTable/components/InfiniteTableRow/row.css" {
     export const GroupRowExpanderCls: string;
 }
 declare module "components/InfiniteTable/state/getComputedPivotColumnsFromDataSourcePivotColumns" {
-    import { DataSourcePropGroupRowsBy, DataSourcePropPivotBy } from "components/DataSource/index";
+    import { DataSourcePropGroupBy, DataSourcePropPivotBy } from "components/DataSource/index";
     import { InfiniteTableProps } from "components/InfiniteTable/types/index";
     import { InfiniteTableState } from "components/InfiniteTable/types/InfiniteTableState";
     export function getComputedPivotColumnsFromDataSourcePivotColumns<T>(pivotColumns: InfiniteTableProps<T>['pivotColumns'], params: {
@@ -1599,13 +1667,13 @@ declare module "components/InfiniteTable/state/getComputedPivotColumnsFromDataSo
         pivotRowLabelsColumn: InfiniteTableProps<T>['pivotRowLabelsColumn'];
         pivotTotalColumnPosition: InfiniteTableState<T>['pivotTotalColumnPosition'];
         pivotBy: DataSourcePropPivotBy<T>;
-        groupRowsBy: DataSourcePropGroupRowsBy<T>;
+        groupBy: DataSourcePropGroupBy<T>;
     }): InfiniteTableProps<T>['pivotColumns'];
 }
 declare module "components/InfiniteTable/utils/getColumnForGroupBy" {
     import * as React from 'react';
     import { InfiniteTableColumnRenderParam } from "components/InfiniteTable/index";
-    import { DataSourceGroupRowsBy } from "components/DataSource/index";
+    import { DataSourceGroupBy } from "components/DataSource/index";
     import { InfiniteTableGeneratedGroupColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
     import { InfiniteTableGroupColumnGetterOptions, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy } from "components/InfiniteTable/types/InfiniteTableProps";
     export function getGroupColumnRender<T>({ groupIndexForColumn, groupRenderStrategy, toggleGroupRow, }: {
@@ -1615,7 +1683,7 @@ declare module "components/InfiniteTable/utils/getColumnForGroupBy" {
     }): (renderOptions: InfiniteTableColumnRenderParam<T>) => React.ReactNode;
     export function getColumnForGroupBy<T>(options: InfiniteTableGroupColumnGetterOptions<T> & {
         groupIndexForColumn: number;
-        groupByForColumn: DataSourceGroupRowsBy<T>;
+        groupByForColumn: DataSourceGroupBy<T>;
     }, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: InfiniteTablePropGroupColumn<T>): InfiniteTableGeneratedGroupColumn<T>;
     export function getSingleGroupColumn<T>(options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: InfiniteTablePropGroupColumn<T>): InfiniteTableGeneratedGroupColumn<T>;
 }
@@ -1625,12 +1693,12 @@ declare module "components/InfiniteTable/hooks/useToggleGroupRow" {
 }
 declare module "components/InfiniteTable/hooks/useColumnsWhen" {
     import type { InfiniteTableColumn } from "components/InfiniteTable/index";
-    import type { DataSourceGroupRowsBy } from "components/DataSource/index";
+    import type { DataSourceGroupBy } from "components/DataSource/index";
     import type { InfiniteTablePropGroupRenderStrategy, InfiniteTableProps } from "components/InfiniteTable/types/InfiniteTableProps";
     export function useColumnsWhen<T>(): void;
     export function getColumnsWhenGrouping<T>(params: {
         columns: Map<string, InfiniteTableColumn<T>>;
-        groupRowsBy: DataSourceGroupRowsBy<T>[];
+        groupBy: DataSourceGroupBy<T>[];
         toggleGroupRow: (groupKeys: any[]) => void;
         groupColumn: InfiniteTableProps<T>['groupColumn'];
         groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
@@ -2621,9 +2689,9 @@ declare module "components/InfiniteTable/hooks/useListRendering" {
     export function useListRendering<T>(param: ListRenderingParam<T>): ListRenderingResult;
 }
 declare module "components/utils/decamelize" {
-    export const decamelize: (input: string, options?: {
+    export function decamelize(str: string, options?: {
         separator: string;
-    } | undefined) => string;
+    }): string;
 }
 declare module "components/InfiniteTable/components/InfiniteTableLicenseFooter/index" {
     import * as React from 'react';
@@ -3060,4 +3128,5 @@ declare module "@infinite-table/infinite-react" {
     export { group, flatten } from "utils/groupAndPivot/index";
     export { useComponentState, getComponentStateRoot, } from "components/hooks/useComponentState";
     export { interceptMap } from "components/hooks/useInterceptedMap";
+    export { useEffectWithChanges } from "components/hooks/useEffectWithChanges";
 }