@infinite-table/infinite-react 0.3.0 → 0.3.3

package/index.d.ts

@@ -46,45 +46,34 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
-declare type SortDir = 1 | -1;
-declare type MultisortInfo<T> = {
-    /**
-     * The sorting direction
-     */
-    dir: SortDir;
-    /**
-     * a property whose value to use for sorting on the array items
-     */
-    field?: keyof T;
-    /**
-     * for now 'string' and 'number' are known types, meaning they have
-     * sort functions already implemented
-     */
-    type?: string;
-    fn?: (a: any, b: any) => number;
-};
-declare const multisort: {
-    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
-    knownTypes: {
-        [key: string]: (first: any, second: any) => number;
-    };
-};
+declare 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 ComponentStateContext<T_STATE, T_ACTIONS> = {
-    getComponentState: () => T_STATE;
-    componentState: T_STATE;
-    componentActions: T_ACTIONS;
-};
-declare type ComponentStateGeneratedActions<T_STATE> = {
-    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
-};
-declare type ComponentInterceptedActions<T_STATE> = {
-    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
-        actions: ComponentStateGeneratedActions<T_STATE>;
-        state: T_STATE;
-    }) => void | boolean;
-};
-declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
+declare type Renderable = React$1.ReactNode | JSX.Element;
+
+interface Size {
+    width: number;
+    height: number;
+}
 
 declare enum InfiniteTableActionType {
     SET_COLUMN_SIZE = 0,
@@ -119,11 +108,6 @@ interface ScrollPosition {
 }
 declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
 
-interface Size {
-    width: number;
-    height: number;
-}
-
 declare type VoidFn = () => void;
 
 declare type FixedPosition = false | 'start' | 'end';
@@ -374,7 +358,23 @@ declare class MatrixBrain extends Logger {
     destroy: () => void;
 }
 
-declare type Renderable = React$1.ReactNode | JSX.Element;
+declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
+    getComponentState: () => T_STATE;
+    componentState: T_STATE;
+    componentActions: T_ACTIONS;
+};
+declare type ComponentStateGeneratedActions<T_STATE> = {
+    [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
+};
+declare type ComponentInterceptedActions<T_STATE> = {
+    [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
+        actions: ComponentStateGeneratedActions<T_STATE>;
+        state: T_STATE;
+    }) => void | boolean;
+};
+declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
+
+declare type NonUndefined<T> = T extends undefined ? never : T;
 
 declare type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
 interface SubscriptionCallback<T> {
@@ -394,8 +394,6 @@ declare class ScrollListener {
     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>>;
@@ -403,7 +401,7 @@ interface InfiniteTableSetupState<T> {
     scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
     portalDOMRef: MutableRefObject<HTMLDivElement | null>;
     onRowHeightCSSVarChange: SubscriptionCallback<number>;
-    onHeaderHeightCSSVarChange: SubscriptionCallback<number>;
+    onColumnHeaderHeightCSSVarChange: SubscriptionCallback<number>;
     columnsWhenGrouping?: InfiniteTablePropColumnsMap<T>;
     bodySize: Size;
     brain: MatrixBrain;
@@ -424,6 +422,7 @@ interface InfiniteTableMappedState<T> {
     scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
     viewportReservedWidth: InfiniteTableProps<T>['viewportReservedWidth'];
     groupColumn: InfiniteTableProps<T>['groupColumn'];
+    headerOptions: NonUndefined<InfiniteTableProps<T>['headerOptions']>;
     onScrollbarsChange: InfiniteTableProps<T>['onScrollbarsChange'];
     loadingText: InfiniteTableProps<T>['loadingText'];
     components: InfiniteTableProps<T>['components'];
@@ -440,6 +439,7 @@ interface InfiniteTableMappedState<T> {
     onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
     onScrollStop: InfiniteTableProps<T>['onScrollStop'];
     scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
+    filterEditors: NonUndefined<InfiniteTableProps<T>['filterEditors']>;
     focusedClassName: InfiniteTableProps<T>['focusedClassName'];
     focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
     focusedStyle: InfiniteTableProps<T>['focusedStyle'];
@@ -467,7 +467,7 @@ interface InfiniteTableMappedState<T> {
     header: NonUndefined<InfiniteTableProps<T>['header']>;
     virtualizeColumns: NonUndefined<InfiniteTableProps<T>['virtualizeColumns']>;
     rowHeight: number;
-    headerHeight: number;
+    columnHeaderHeight: number;
     licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
     columnVisibility: InfiniteTablePropColumnVisibility;
     columnPinning: InfiniteTablePropColumnPinningMap;
@@ -487,7 +487,7 @@ interface InfiniteTableDerivedState<T> {
     columnGroupsMaxDepth: number;
     computedColumnGroups: InfiniteTablePropColumnGroupsMap;
     rowHeightCSSVar: string;
-    headerHeightCSSVar: string;
+    columnHeaderHeightCSSVar: string;
     controlledColumnVisibility: boolean;
 }
 declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
@@ -507,7 +507,6 @@ declare type InfiniteTablePropColumnPinningRecord = Record<string, true | 'start
 declare type InfiniteTablePropColumnPinning = InfiniteTablePropColumnPinningRecord | InfiniteTablePropColumnPinningMap;
 declare type InfiniteTableRowStyleFnParams<T> = {
     rowIndex: number;
-    groupBy?: (keyof T)[];
 } & InfiniteTableRowInfoDataDiscriminator<T>;
 declare type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
 declare type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
@@ -520,9 +519,13 @@ declare type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<Aggr
 declare type InfiniteTableColumnType<T> = {
     minWidth?: number;
     maxWidth?: number;
+    filterType?: string;
+    sortType?: string;
+    dataType?: InfiniteTableDataTypeNames;
     defaultWidth?: number;
     defaultFlex?: number;
     defaultPinned?: InfiniteTableColumnPinnedValues;
+    defaultFilterable?: boolean;
     defaultHiddenWhenGroupedBy?: InfiniteTableColumn<T>['defaultHiddenWhenGroupedBy'];
     header?: InfiniteTableColumn<T>['header'];
     comparer?: InfiniteTableColumn<T>['comparer'];
@@ -537,6 +540,7 @@ declare type InfiniteTableColumnType<T> = {
     renderValue?: InfiniteTableColumn<T>['renderValue'];
     render?: InfiniteTableColumn<T>['render'];
     valueGetter?: InfiniteTableColumn<T>['valueGetter'];
+    valueFormatter?: InfiniteTableColumn<T>['valueFormatter'];
     style?: InfiniteTableColumn<T>['style'];
 };
 declare type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
@@ -610,6 +614,15 @@ declare type ScrollStopInfo = {
     firstVisibleRowIndex: number;
     lastVisibleRowIndex: number;
 };
+declare type InfiniteTablePropFilterEditors<T> = Record<string, React$1.FC<InfiniteTableFilterEditorProps<T>>>;
+declare type InfiniteTableFilterEditorProps<T extends any> = {
+    filterType: string;
+    operator: string;
+    ariaLabel: string;
+    filterValue: T;
+    className: string;
+    onChange: (value: T | undefined) => void;
+};
 interface InfiniteTableProps<T> {
     columns: InfiniteTablePropColumns<T>;
     pivotColumns?: InfiniteTablePropColumnsMap<T, InfiniteTablePivotColumn<T>>;
@@ -643,13 +656,14 @@ interface InfiniteTableProps<T> {
     rowHeight: number | string;
     rowStyle?: InfiniteTablePropRowStyle<T>;
     rowClassName?: InfiniteTablePropRowClassName<T>;
-    headerHeight: number | string;
+    columnHeaderHeight: number | string;
     domProps?: React$1.HTMLProps<HTMLDivElement>;
     showZebraRows?: boolean;
     showHoverRows?: boolean;
     sortable?: boolean;
     draggableColumns?: boolean;
     header?: boolean;
+    headerOptions?: InfiniteTablePropHeaderOptions;
     focusedClassName?: string;
     focusedWithinClassName?: string;
     focusedStyle?: React$1.CSSProperties;
@@ -677,12 +691,16 @@ interface InfiniteTableProps<T> {
     columnOrder?: InfiniteTablePropColumnOrder;
     onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrder) => void;
     onRowHeightChange?: (rowHeight: number) => void;
+    filterEditors?: InfiniteTablePropFilterEditors<T>;
     onReady?: (api: InfiniteTableImperativeApi<T>) => void;
     rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStyleFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
     licenseKey?: string;
     scrollTopKey?: string | number;
     autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
 }
+declare type InfiniteTablePropHeaderOptions = {
+    alwaysReserveSpaceForSortIcon: boolean;
+};
 declare type InfiniteTablePropAutoSizeColumnsKey = string | number | {
     key: string | number;
     columnsToSkip?: string[];
@@ -699,6 +717,7 @@ interface InfiniteTableComputedValues<T> {
         vertical: boolean;
         horizontal: boolean;
     };
+    showColumnFilters: boolean;
     rowspan?: MatrixBrainOptions['rowspan'];
     computedPinnedStartOverflow: boolean;
     computedPinnedEndOverflow: boolean;
@@ -729,216 +748,207 @@ interface InfiniteTableContextValue<T> {
     getState: () => InfiniteTableState<T>;
 }
 
-declare type RenderRange = {
-    renderStartIndex: number;
-    renderEndIndex: number;
+declare type InfiniteTableBaseCellProps<T> = {
+    column: InfiniteTableComputedColumn<T>;
+    renderChildren: () => Renderable;
+    width: number;
+    cssEllipsis?: boolean;
+    contentStyle?: CSSProperties;
+    contentClassName?: string;
+    virtualized?: boolean;
+    skipColumnShifting?: boolean;
+    beforeChildren?: Renderable;
+    afterChildren?: Renderable;
+    offset?: number;
+    offsetProperty?: 'left' | 'right';
+    cssPosition?: CSSProperties['position'];
+    domRef?: React.RefCallback<HTMLElement>;
 };
+declare type InfiniteTableCellProps<T> = ({
+    cellType: 'header';
+} & InfiniteTableBaseCellProps<T>) | ({
+    cellType: 'body';
+} & InfiniteTableBaseCellProps<T>);
 
-interface DataSourceDataParams<T> {
-    originalDataArray: T[];
-    sortInfo?: DataSourceSortInfo<T>;
-    groupBy?: DataSourcePropGroupBy<T>;
-    pivotBy?: DataSourcePropPivotBy<T>;
-    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
-    lazyLoadBatchSize?: number;
-    lazyLoadStartIndex?: number;
-    groupKeys?: any[];
-    append?: boolean;
-    aggregationReducers?: DataSourcePropAggregationReducers<T>;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-    __cursorId?: DataSourceSetupState<T>['cursorId'];
-    changes?: DataSourceDataParamsChanges<T>;
-}
-declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
-declare type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
-    field?: keyof T;
-    id?: string;
-};
-declare type DataSourceGroupBy<T> = GroupBy<T, any>;
-declare type DataSourcePivotBy<T> = PivotBy<T, any>;
-declare type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
-declare type DataSourceRemoteData<T> = {
-    data: T[] | LazyGroupDataItem<T>[];
-    mappings?: DataSourceMappings;
-    cache?: boolean;
-    totalCount?: number;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+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 DiscriminatedUnion<A, B> = (A & {
+    [K in keyof B]?: undefined;
+}) | (B & {
+    [K in keyof A]?: undefined;
+});
+
+declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
+declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    sortTool: JSX.Element | null;
+    column: COL_TYPE;
+    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
+    columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
 };
-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 DataSourcePropGroupRowsStateObject<KeyType> = {
-    expandedRows: DataSourceGroupRowsList<KeyType>;
-    collapsedRows: DataSourceGroupRowsList<KeyType>;
+declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
+    value: string | number | Renderable;
+    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
+    rowIndex: number;
+    column: COL_TYPE;
+    toggleCurrentGroupRow: () => void;
+    toggleGroupRow: InfiniteTableToggleGroupRowFn;
+    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
+    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
 };
-declare type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
-declare type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
-interface DataSourceMappedState<T> {
-    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
-    livePagination: DataSourceProps<T>['livePagination'];
-    lazyLoad: DataSourceProps<T>['lazyLoad'];
-    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
-    data: DataSourceProps<T>['data'];
-    primaryKey: DataSourceProps<T>['primaryKey'];
-    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
-    groupRowsState: GroupRowsState<T>;
-    pivotBy: DataSourceProps<T>['pivotBy'];
-    loading: NonUndefined<DataSourceProps<T>['loading']>;
-    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
-    sortInfo: DataSourceSingleSortInfo<T>[] | null;
-}
-declare type DataSourceAggregationReducer<T, AggregationResultType> = {
-    name?: string;
-    field?: keyof T;
-    initialValue?: AggregationResultType;
-    getter?: (data: T) => any;
-    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
-    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
-    pivotColumn?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<T>>> | (({ column, }: {
-        column: InfiniteTablePivotFinalColumnVariant<T>;
-    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotColumn<T>>>);
+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 ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
-    inheritFromColumn?: string | boolean;
+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 DataSourceMappings = Record<'totals' | 'values', string>;
-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 InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
+declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
+    data: DATA_TYPE | Partial<DATA_TYPE> | null;
+    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
+    rowIndex: number;
+    column: COL_TYPE;
 };
-declare type LazyRowInfoGroup<DataType> = {
+declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
+declare type InfiniteTableGroupColumnRenderIconFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (param: InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
+declare type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderParams<T>) => Renderable;
+declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
+declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
+declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
+declare type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
+declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
+declare type InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T> = RequireAtLeastOne<{
     /**
-     * Those are direct children of the current lazy group row
+     * Determines the field property of the column.
      */
-    children: LazyGroupDataItem<DataType>[];
-    childrenLoading: boolean;
-    childrenAvailable: boolean;
-    cache: boolean;
-    totalCount: number;
-    error?: string;
+    field?: keyof T;
+    render?: InfiniteTableColumnRenderFunction<T>;
+    renderValue?: InfiniteTableColumnRenderFunction<T>;
+    valueGetter?: InfiniteTableColumnValueGetter<T>;
+    valueFormatter?: InfiniteTableColumnValueFormatter<T>;
+}, 'render' | 'renderValue' | 'field' | 'valueGetter' | 'valueFormatter'>;
+declare type InfiniteTableColumnStyleFnParams<T> = {
+    value: Renderable;
+    column: InfiniteTableColumn<T>;
+} & InfiniteTableRowInfoDataDiscriminator<T>;
+declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
+declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
+declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
+declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
+declare type InfiniteTableColumnValueGetterParams<T> = {
+    data: T;
+    field?: keyof T;
 };
-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;
-    dataParams?: DataSourceDataParams<T>;
-    originalLazyGroupData: LazyGroupDataDeepMap<T>;
-    originalLazyGroupDataChangeDetect: number | string;
-    scrollStopDelayUpdatedByTable: number;
-    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
-    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
-    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
-    originalDataArray: T[];
-    lastSortDataArray?: T[];
-    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
-    dataArray: InfiniteTableRowInfo<T>[];
-    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
-    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
-    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
-    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
-    updatedAt: number;
-    reducedAt: number;
-    groupedAt: number;
-    sortedAt: number;
-    generateGroupRows: boolean;
-    postSortDataArray?: T[];
-    postGroupDataArray?: InfiniteTableRowInfo<T>[];
-    pivotColumns?: Map<string, InfiniteTableColumn<T>>;
-    pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
-}
-declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
-declare type DataSourceProps<T> = {
-    children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
-    primaryKey: keyof T;
-    fields?: (keyof T)[];
-    data: DataSourceData<T>;
-    lazyLoad?: boolean | {
-        batchSize?: number;
+declare type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
+declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
+declare type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
+declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
+declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
+declare type InfiniteTableBaseColumn<T> = {
+    sortable?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    comparer?: InfiniteTableColumnComparer<T>;
+    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
+        [k in keyof Partial<T>]: true;
+    };
+    align?: InfiniteTableColumnAlign;
+    verticalAlign?: InfiniteTableColumnVerticalAlign;
+    columnGroup?: string;
+    header?: InfiniteTableColumnHeader<T>;
+    name?: Renderable;
+    cssEllipsis?: boolean;
+    headerCssEllipsis?: boolean;
+    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
+    dataType?: InfiniteTableDataTypeNames;
+    sortType?: string;
+    filterType?: string;
+    style?: InfiniteTableColumnStyle<T>;
+    className?: InfiniteTableColumnClassName<T>;
+    rowspan?: InfiniteTableColumnRowspanFn<T>;
+    valueGetter?: InfiniteTableColumnValueGetter<T>;
+    valueFormatter?: InfiniteTableColumnValueFormatter<T>;
+    defaultWidth?: number;
+    defaultFlex?: number;
+    defaultFilterable?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    components?: {
+        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
     };
-    loading?: boolean;
-    defaultLoading?: boolean;
-    onLoadingChange?: (loading: boolean) => void;
-    pivotBy?: DataSourcePropPivotBy<T>;
-    defaultPivotBy?: DataSourcePropPivotBy<T>;
-    onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
-    aggregationReducers?: DataSourcePropAggregationReducers<T>;
-    defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
-    groupBy?: DataSourcePropGroupBy<T>;
-    defaultGroupBy?: DataSourcePropGroupBy<T>;
-    onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
-    groupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
-    defaultGroupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<keyof T>;
-    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
-    collapseGroupRowsOnDataFunctionChange?: boolean;
-    sortInfo?: DataSourceSortInfo<T>;
-    defaultSortInfo?: DataSourceSortInfo<T>;
-    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
-    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
-    livePagination?: boolean;
-    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
-    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
 };
-declare type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
-declare type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
-declare type DataSourceLivePaginationCursorParams<T> = {
-    array: T[];
-    lastItem: T | Partial<T> | null;
-    length: number;
+/**
+ * Defines a column in the table.
+ *
+ * @typeParam DATA_TYPE The type of the data in the table.
+ *
+ * Can be bound to a field which is a `keyof DATA_TYPE`.
+ */
+declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<DATA_TYPE>;
+declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
+    groupByField: string | string[];
+    id?: string;
 };
-declare type DataSourceLivePaginationCursorValue = string | number | null;
-interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
-}
-interface DataSourceDerivedState<_T> {
-    multiSort: boolean;
-    controlledSort: boolean;
-    livePaginationCursor?: DataSourceLivePaginationCursorValue;
-    lazyLoadBatchSize?: number;
-}
-declare type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
-interface DataSourceContextValue<T> {
-    getState: () => DataSourceState<T>;
-    componentState: DataSourceState<T>;
-    componentActions: DataSourceComponentActions<T>;
-}
-declare enum DataSourceActionType {
-    INIT = "INIT"
-}
-interface DataSourceAction<T> {
-    type: DataSourceActionType;
-    payload: T;
-}
-interface DataSourceReducer<T> {
-    (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
-}
-
-declare class GroupRowsState<KeyType extends any = any> {
-    private expandedMap?;
-    private collapsedMap?;
-    private collapsedAll;
-    private expandedAll;
-    private initialState;
-    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
-    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
-    destroy(): void;
-    private update;
-    areAllCollapsed(): boolean;
-    areAllExpanded(): boolean;
-    collapseAll(): void;
-    expandAll(): void;
-    isGroupRowExpanded(keys: KeyType[]): boolean | undefined;
-    isGroupRowCollapsed(keys: KeyType[]): boolean;
-    setGroupRowExpanded(keys: KeyType[], shouldExpand: boolean): void;
-    collapseGroupRow(keys: KeyType[]): void;
-    expandGroupRow(keys: KeyType[]): void;
-    toggleGroupRow(keys: KeyType[]): void;
-}
+declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
+declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotTotalColumnGroup?: true;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex: PivotBy<DataType, KeyType>;
+    pivotGroupKey: KeyType;
+    pivotIndex: number;
+};
+declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
+    pivotBy: DataSourcePivotBy<DataType>[];
+    pivotColumn: true;
+    pivotTotalColumn: boolean;
+    pivotAggregator: AggregationReducer<DataType, any>;
+    pivotAggregatorIndex: number;
+    pivotGroupKeys: KeyType[];
+    pivotByAtIndex?: PivotBy<DataType, KeyType>;
+    pivotIndex: number;
+    pivotGroupKey: KeyType;
+};
+declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
+declare type InfiniteTableComputedColumnBase<T> = {
+    computedFilterType: string;
+    computedSortType: string;
+    computedDataType: string;
+    computedWidth: number;
+    computedOffset: number;
+    computedPinningOffset: number;
+    computedAbsoluteOffset: number;
+    computedSortable: boolean;
+    computedSortInfo: DataSourceSingleSortInfo<T> | null;
+    computedSorted: boolean;
+    computedSortedAsc: boolean;
+    computedSortedDesc: boolean;
+    computedSortIndex: number;
+    computedVisibleIndex: number;
+    computedMultiSort: boolean;
+    computedFiltered: boolean;
+    computedFilterable: boolean;
+    computedFilterValue: DataSourceFilterValueItem<T> | null;
+    computedPinned: InfiniteTableColumnPinnedValues;
+    computedDraggable: boolean;
+    computedFirstInCategory: boolean;
+    computedLastInCategory: boolean;
+    computedFirst: boolean;
+    computedLast: boolean;
+    toggleSort: () => void;
+    id: string;
+};
+declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
+declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
 
 declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
     id: string;
@@ -960,10 +970,14 @@ declare type InfiniteTableRowInfoDataDiscriminator<T> = {
     data: T;
     isGroupRow: false;
     rowInfo: InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoNormal<T>;
+    field?: keyof T;
+    value: any;
 } | {
     data: Partial<T> | null;
     rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<T>;
     isGroupRow: true;
+    field?: keyof T;
+    value: any;
 };
 /**
  * This is the base row info for all scenarios - things every
@@ -974,7 +988,6 @@ declare type InfiniteTable_RowInfoBase<_T> = {
     id: any;
     value?: any;
     indexInAll: number;
-    indexInGroup: number;
 };
 declare type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
     dataSourceHasGrouping: true;
@@ -990,6 +1003,7 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
      * 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.
@@ -1024,7 +1038,7 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
      * 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 or some of) the children have been loaded, it only means that at least some children have been requested.
+     * 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.
      */
@@ -1047,6 +1061,7 @@ declare type InfiniteTable_NoGrouping_RowInfoNormal<T> = {
     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.
      *
@@ -1183,177 +1198,289 @@ declare type DataGroupResult<DataType, KeyType extends any> = {
 declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
 declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
 
-declare type InfiniteTableCellProps<T> = {
-    column: InfiniteTableComputedColumn<T>;
-    renderChildren: () => Renderable;
-    width: number;
-    cssEllipsis?: boolean;
-    virtualized?: boolean;
-    skipColumnShifting?: boolean;
-    beforeChildren?: Renderable;
-    afterChildren?: Renderable;
-    offset?: number;
-    offsetProperty?: 'left' | 'right';
-    cssPosition?: CSSProperties['position'];
-    domRef?: React.RefCallback<HTMLElement>;
-    cellType: 'body' | 'header';
-};
-
-declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-}[Keys];
-
-declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
-declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    sortTool: JSX.Element;
-    column: COL_TYPE;
-    columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
+declare type SortDir = 1 | -1;
+declare type MultisortInfo<T> = {
+    /**
+     * The sorting direction
+     */
+    dir: SortDir;
+    /**
+     * for now 'string' and 'number' are known types, meaning they have
+     * sort functions already implemented
+     */
+    type?: string;
+    fn?: (a: any, b: any) => number;
+    /**
+     * a property whose value to use for sorting on the array items
+     */
+    field?: keyof T;
+    /**
+     * or a function to retrieve the item value to use for sorting
+     */
+    valueGetter?: (item: T) => any;
 };
-declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    value: string | number | Renderable;
-    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
-    rowIndex: number;
-    column: COL_TYPE;
-    toggleCurrentGroupRow: () => void;
-    toggleGroupRow: InfiniteTableToggleGroupRowFn;
-    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
-    pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
+declare const multisort: {
+    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
 };
-declare type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
-declare type InfiniteTableGroupColumnRenderParams<DATA_TYPE, COL_TYPE> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & {
-    rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<DATA_TYPE>;
-    isGroupRow: true;
-    data: Partial<DATA_TYPE> | null;
+
+declare type RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
 };
-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;
+
+interface DataSourceDataParams<T> {
+    originalDataArray: T[];
+    sortInfo?: DataSourceSortInfo<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    filterValue?: DataSourcePropFilterValue<T>;
+    groupRowsState?: DataSourcePropGroupRowsStateObject<any>;
+    lazyLoadBatchSize?: number;
+    lazyLoadStartIndex?: number;
+    groupKeys?: any[];
+    append?: boolean;
+    aggregationReducers?: DataSourcePropAggregationReducers<T>;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    __cursorId?: DataSourceSetupState<T>['cursorId'];
+    changes?: DataSourceDataParamsChanges<T>;
+}
+declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
+declare type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
+    field?: keyof T;
+    id?: string;
 };
-declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
-declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
-    rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
-    data: DATA_TYPE | Partial<DATA_TYPE> | null;
-    dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
-    rowIndex: number;
-    column: COL_TYPE;
+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[] | LazyGroupDataItem<T>[];
+    mappings?: DataSourceMappings;
+    cache?: boolean;
+    error?: string;
+    totalCount?: number;
+    totalCountUnfiltered?: number;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
 };
-declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableGroupColumnRenderIconFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (param: InfiniteTableGroupColumnRenderIconParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderParams<T>) => Renderable;
-declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
-declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
-declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
-declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
-declare type InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T> = RequireAtLeastOne<{
-    /**
-     * Determines the field property of the column.
-     */
+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 DataSourcePropGroupRowsStateObject<KeyType> = {
+    expandedRows: DataSourceGroupRowsList<KeyType>;
+    collapsedRows: DataSourceGroupRowsList<KeyType>;
+};
+declare type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
+declare type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
+interface DataSourceMappedState<T> {
+    aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
+    livePagination: DataSourceProps<T>['livePagination'];
+    lazyLoad: DataSourceProps<T>['lazyLoad'];
+    onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
+    data: DataSourceProps<T>['data'];
+    filterFunction: DataSourceProps<T>['filterFunction'];
+    filterValue: DataSourceProps<T>['filterValue'];
+    filterTypes: NonUndefined<DataSourceProps<T>['filterTypes']>;
+    primaryKey: DataSourceProps<T>['primaryKey'];
+    filterDelay: NonUndefined<DataSourceProps<T>['filterDelay']>;
+    groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
+    groupRowsState: GroupRowsState<T>;
+    pivotBy: DataSourceProps<T>['pivotBy'];
+    loading: NonUndefined<DataSourceProps<T>['loading']>;
+    sortTypes: NonUndefined<DataSourceProps<T>['sortTypes']>;
+    collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
+    sortInfo: DataSourceSingleSortInfo<T>[] | null;
+}
+declare type DataSourceAggregationReducer<T, AggregationResultType> = {
+    name?: string;
     field?: keyof T;
-    render?: InfiniteTableColumnRenderFunction<T>;
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
-}, 'render' | 'renderValue' | 'field' | 'valueGetter'>;
-declare type InfiniteTableColumnStyleFnParams<T> = {
-    value: Renderable;
-    column: InfiniteTableColumn<T>;
-} & InfiniteTableRowInfoDataDiscriminator<T>;
-declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
-declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
-declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
-declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
-declare type InfiniteTableColumnValueGetterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
-declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
-declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
-declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
-declare type InfiniteTableBaseColumn<T> = {
-    sortable?: boolean;
-    draggable?: boolean;
-    resizable?: boolean;
-    comparer?: InfiniteTableColumnComparer<T>;
-    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
-        [k in keyof Partial<T>]: true;
-    };
-    align?: InfiniteTableColumnAlign;
-    verticalAlign?: InfiniteTableColumnVerticalAlign;
-    columnGroup?: string;
-    header?: InfiniteTableColumnHeader<T>;
-    name?: Renderable;
-    cssEllipsis?: boolean;
-    headerCssEllipsis?: boolean;
-    type?: InfiniteTableColumnTypeNames | InfiniteTableColumnTypeNames[] | null;
-    style?: InfiniteTableColumnStyle<T>;
-    className?: InfiniteTableColumnClassName<T>;
-    rowspan?: InfiniteTableColumnRowspanFn<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
-    defaultWidth?: number;
-    defaultFlex?: number;
-    minWidth?: number;
-    maxWidth?: number;
-    components?: {
-        ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
-        HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
+    initialValue?: AggregationResultType;
+    getter?: (data: T) => any;
+    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
+    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+    pivotColumn?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<T>>> | (({ column, }: {
+        column: InfiniteTablePivotFinalColumnVariant<T>;
+    }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotColumn<T>>>);
+};
+declare type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
+    inheritFromColumn?: string | boolean;
+};
+declare type DataSourceMappings = Record<'totals' | 'values', string>;
+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>;
     };
 };
-/**
- * Defines a column in the table.
- *
- * @typeParam DATA_TYPE The type of the data in the table.
- *
- * Can be bound to a field which is a `keyof DATA_TYPE`.
- */
-declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<DATA_TYPE>;
-declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
-    groupByField: string | string[];
-    id?: string;
+declare type LazyRowInfoGroup<DataType> = {
+    /**
+     * Those are direct children of the current lazy group row
+     */
+    children: LazyGroupDataItem<DataType>[];
+    childrenLoading: boolean;
+    childrenAvailable: boolean;
+    cache: boolean;
+    totalCount: number;
+    totalCountUnfiltered: number;
+    error?: string;
 };
-declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
-declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotTotalColumnGroup?: true;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex: PivotBy<DataType, KeyType>;
-    pivotGroupKey: KeyType;
-    pivotIndex: number;
+declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
+interface DataSourceSetupState<T> {
+    unfilteredCount: number;
+    filteredCount: number;
+    lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
+    pivotMappings?: DataSourceMappings;
+    propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
+    showSeparatePivotColumnForSingleAggregation: boolean;
+    dataParams?: DataSourceDataParams<T>;
+    originalLazyGroupData: LazyGroupDataDeepMap<T>;
+    originalLazyGroupDataChangeDetect: number | string;
+    scrollStopDelayUpdatedByTable: number;
+    notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
+    notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
+    notifyRenderRangeChange: SubscriptionCallback<RenderRange>;
+    originalDataArray: T[];
+    lastFilterDataArray?: T[];
+    lastSortDataArray?: T[];
+    lastGroupDataArray?: InfiniteTableRowInfo<T>[];
+    dataArray: InfiniteTableRowInfo<T>[];
+    groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
+    pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
+    pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
+    cursorId: number | symbol | DataSourceLivePaginationCursorValue;
+    updatedAt: number;
+    reducedAt: number;
+    groupedAt: number;
+    sortedAt: number;
+    filteredAt: number;
+    generateGroupRows: boolean;
+    postFilterDataArray?: T[];
+    postSortDataArray?: T[];
+    postGroupDataArray?: InfiniteTableRowInfo<T>[];
+    pivotColumns?: Map<string, InfiniteTableColumn<T>>;
+    pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
+}
+declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
+declare type DataSourceProps<T> = {
+    children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
+    primaryKey: keyof T | (({ data, index }: {
+        data: T;
+        index: number;
+    }) => string);
+    fields?: (keyof T)[];
+    data: DataSourceData<T>;
+    lazyLoad?: boolean | {
+        batchSize?: number;
+    };
+    loading?: boolean;
+    defaultLoading?: boolean;
+    onLoadingChange?: (loading: boolean) => void;
+    pivotBy?: DataSourcePropPivotBy<T>;
+    defaultPivotBy?: DataSourcePropPivotBy<T>;
+    onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
+    aggregationReducers?: DataSourcePropAggregationReducers<T>;
+    defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
+    groupBy?: DataSourcePropGroupBy<T>;
+    defaultGroupBy?: DataSourcePropGroupBy<T>;
+    onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
+    groupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<any>;
+    defaultGroupRowsState?: GroupRowsState | DataSourcePropGroupRowsStateObject<keyof T>;
+    onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
+    collapseGroupRowsOnDataFunctionChange?: boolean;
+    sortInfo?: DataSourceSortInfo<T>;
+    defaultSortInfo?: DataSourceSortInfo<T>;
+    onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
+    onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
+    livePagination?: boolean;
+    livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
+    onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
+    filterFunction?: DataSourcePropFilterFunction<T>;
+    filterMode?: 'client' | 'server';
+    filterValue?: DataSourcePropFilterValue<T>;
+    defaultFilterValue?: DataSourcePropFilterValue<T>;
+    onFilterValueChange?: (filterValue: DataSourcePropFilterValue<T>) => void;
+    filterDelay?: number;
+    filterTypes?: DataSourcePropFilterTypes<T>;
+    sortTypes?: DataSourcePropSortTypes;
 };
-declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
-    pivotBy: DataSourcePivotBy<DataType>[];
-    pivotColumn: true;
-    pivotTotalColumn: boolean;
-    pivotAggregator: AggregationReducer<DataType, any>;
-    pivotAggregatorIndex: number;
-    pivotGroupKeys: KeyType[];
-    pivotByAtIndex?: PivotBy<DataType, KeyType>;
-    pivotIndex: number;
-    pivotGroupKey: KeyType;
+declare type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
+declare type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
+declare type DataSourceFilterFunctionParam<T> = {
+    data: T;
+    index: number;
+    dataArray: T[];
+    primaryKey: any;
 };
-declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
-declare type InfiniteTableComputedColumnBase<T> = {
-    computedWidth: number;
-    computedOffset: number;
-    computedPinningOffset: number;
-    computedAbsoluteOffset: number;
-    computedSortable: boolean;
-    computedSortInfo: DataSourceSingleSortInfo<T> | null;
-    computedSorted: boolean;
-    computedSortedAsc: boolean;
-    computedSortedDesc: boolean;
-    computedSortIndex: number;
-    computedVisibleIndex: number;
-    computedMultiSort: boolean;
-    computedPinned: InfiniteTableColumnPinnedValues;
-    computedDraggable: boolean;
-    computedFirstInCategory: boolean;
-    computedLastInCategory: boolean;
-    computedFirst: boolean;
-    computedLast: boolean;
-    toggleSort: () => void;
+declare type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
+declare type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
+declare type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
+    field: keyof T;
+}, {
     id: string;
+}> & {
+    valueGetter?: DataSourceFilterValueItemValueGetter<T>;
+    filterValue: any;
+    disabled?: boolean;
+    filterType: string;
+    operator: string;
 };
-declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
-declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
+declare type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T>) => any;
+declare type DataSourceFilterType<T> = {
+    emptyValues: Set<any>;
+    label?: string;
+    defaultOperator: string;
+    operators: DataSourceFilterOperator<T>[];
+};
+declare type DataSourceFilterOperator<T> = {
+    name: string;
+    label?: string;
+    fn: DataSourceFilterOperatorFunction<T>;
+};
+declare type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
+declare type DataSourceFilterOperatorFunctionParam<T> = {
+    currentValue: any;
+    filterValue: any;
+    emptyValues: Set<any>;
+} & DataSourceFilterFunctionParam<T>;
+declare type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
+declare type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
+declare type DataSourceLivePaginationCursorParams<T> = {
+    array: T[];
+    lastItem: T | Partial<T> | null;
+    length: number;
+};
+declare type DataSourceLivePaginationCursorValue = string | number | null;
+interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
+}
+interface DataSourceDerivedState<T> {
+    operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
+    filterMode: NonUndefined<DataSourceProps<T>['filterMode']>;
+    multiSort: boolean;
+    controlledSort: boolean;
+    controlledFilter: boolean;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
+    lazyLoadBatchSize?: number;
+}
+declare type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
+interface DataSourceContextValue<T> {
+    getState: () => DataSourceState<T>;
+    componentState: DataSourceState<T>;
+    componentActions: DataSourceComponentActions<T>;
+}
+declare enum DataSourceActionType {
+    INIT = "INIT"
+}
+interface DataSourceAction<T> {
+    type: DataSourceActionType;
+    payload: T;
+}
+interface DataSourceReducer<T> {
+    (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
+}
 
 declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParams<T, InfiniteTableComputedColumn<T>>;
 
@@ -1365,10 +1492,12 @@ declare function InfiniteTable<T>(props: InfiniteTableProps<T>): JSX.Element;
 declare namespace InfiniteTable {
     var defaultProps: {
         rowHeight: number;
-        headerHeight: _vanilla_extract_private.CSSVarFunction;
+        columnHeaderHeight: _vanilla_extract_private.CSSVarFunction;
     };
 }
 
+declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
+
 declare function useDataSource<T>(): DataSourceState<T>;
 
 declare function DataSource<T>(props: DataSourceProps<T>): JSX.Element;
@@ -1424,4 +1553,8 @@ 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, 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 };
+declare const defaultFilterEditors: InfiniteTablePropFilterEditors<unknown>;
+declare function StringFilterEditor<T>(props: InfiniteTableFilterEditorProps<T>): JSX.Element;
+declare function NumberFilterEditor<T>(props: InfiniteTableFilterEditorProps<T>): JSX.Element;
+
+export { ColumnTypeWithInherit, DataSource, DataSourceAction, DataSourceActionType, DataSourceAggregationReducer, DataSourceComponentActions, DataSourceContextValue, DataSourceData, DataSourceDataParams, DataSourceDataParamsChanges, DataSourceDerivedState, DataSourceFilterFunctionParam, DataSourceFilterOperator, DataSourceFilterOperatorFunction, DataSourceFilterOperatorFunctionParam, DataSourceFilterType, DataSourceFilterValueItem, DataSourceFilterValueItemValueGetter, DataSourceGroupBy, DataSourceGroupRowsList, DataSourceLivePaginationCursorFn, DataSourceLivePaginationCursorParams, DataSourceLivePaginationCursorValue, DataSourceMappedState, DataSourceMappings, DataSourcePivotBy, DataSourcePropAggregationReducers, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropLivePaginationCursor, DataSourcePropPivotBy, DataSourcePropSortTypes, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableFilterEditorProps, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTableGroupColumnRenderIconFunction, InfiniteTableImperativeApi, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTablePropFilterEditors, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, NumberFilterEditor, Scrollbars, StringFilterEditor, debounce, defaultFilterEditors, defaultFilterTypes, defaultFilterTypes as filterTypes, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };