@infinite-table/infinite-react 0.3.1 → 0.3.4

package/index.d.ts

@@ -1,6 +1,6 @@
 import * as _vanilla_extract_private from '@vanilla-extract/private';
 import * as React$1 from 'react';
-import { MutableRefObject, CSSProperties, HTMLProps } from 'react';
+import { RefCallback, MutableRefObject, CSSProperties, HTMLProps } from 'react';
 
 declare function debounce(fn: Function, { wait }: {
     wait: number;
@@ -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';
@@ -319,7 +303,7 @@ declare class MatrixBrain extends Logger {
         x: number;
         y: number;
     };
-    private getItemOffsetFor;
+    getItemOffsetFor: (itemIndex: number, direction: 'horizontal' | 'vertical') => number;
     private computeCacheFor;
     private getItemSizeCacheFor;
     private computeItemSpanUpTo;
@@ -374,7 +358,106 @@ declare class MatrixBrain extends Logger {
     destroy: () => void;
 }
 
-declare type Renderable = React$1.ReactNode | JSX.Element;
+declare type TableRenderCellFnParam = {
+    domRef: RefCallback<HTMLElement>;
+    rowIndex: number;
+    colIndex: number;
+    rowspan: number;
+    colspan: number;
+    hidden: boolean;
+    width: number;
+    height: number;
+    widthWithColspan: number;
+    heightWithRowspan: number;
+    rowFixed: FixedPosition;
+    colFixed: FixedPosition;
+    onMouseEnter: VoidFunction;
+    onMouseLeave: VoidFunction;
+};
+declare type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
+declare class ReactHeadlessTableRenderer extends Logger {
+    private brain;
+    private destroyed;
+    private scrolling;
+    cellHoverClassNames: string[];
+    private itemDOMElements;
+    private itemDOMRefs;
+    private updaters;
+    private mappedCells;
+    private items;
+    private currentHoveredRow;
+    private onDestroy;
+    private hoverRowUpdatesInProgress;
+    constructor(brain: MatrixBrain);
+    getFullyVisibleRowsRange: () => {
+        start: number;
+        end: number;
+    } | null;
+    getScrollPositionForScrollRowIntoView: (rowIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => ScrollPosition;
+    getScrollPositionForScrollColumnIntoView: (colIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => ScrollPosition;
+    getScrollPositionForScrollCellIntoView: (rowIndex: number, colIndex: number, config?: {
+        rowScrollAdjustPosition?: ScrollAdjustPosition;
+        colScrollAdjustPosition?: ScrollAdjustPosition;
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offsetTop: number;
+        offsetLeft: number;
+    }) => ScrollPosition;
+    isRowFullyVisible: (rowIndex: number, offsetMargin?: number) => boolean;
+    isRowVisible: (rowIndex: number, offsetMargin?: number) => boolean;
+    isRowRendered: (rowIndex: number) => boolean;
+    isCellVisible: (rowIndex: number, colIndex: number) => boolean;
+    isCellFullyVisible: (rowIndex: number, colIndex: number) => boolean;
+    isColumnFullyVisible: (colIndex: number, offsetMargin?: number) => boolean;
+    isColumnVisible: (colIndex: number, offsetMargin?: number) => boolean;
+    isCellRendered: (rowIndex: number, colIndex: number) => boolean;
+    isColumnRendered: (colIndex: number) => boolean;
+    getExtraSpanCellsForRange: (range: TableRenderRange) => [number, number][];
+    renderRange: (range: TableRenderRange, { renderCell, force, onRender, }: {
+        force?: boolean | undefined;
+        renderCell: TableRenderCellFn;
+        onRender: (items: Renderable[]) => void;
+    }) => Renderable[];
+    private renderElement;
+    getFixedRanges: (currentRenderRange: TableRenderRange) => TableRenderRange[];
+    private isCellFixed;
+    private isCellCovered;
+    private renderCellAtElement;
+    private onMouseEnter;
+    private addHoverClass;
+    private onMouseLeave;
+    private removeHoverClass;
+    private updateHoverClassNamesForRow;
+    private updateElementPosition;
+    private onScrollStart;
+    private onScrollStop;
+    adjustFixedElementsOnScroll: (scrollPosition?: ScrollPosition) => void;
+    destroy: () => void;
+    reset(): 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 NonUndefined<T> = T extends undefined ? never : T;
 
 declare type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
 interface SubscriptionCallback<T> {
@@ -394,16 +477,16 @@ declare class ScrollListener {
     destroy: () => void;
 }
 
-declare type NonUndefined<T> = T extends undefined ? never : T;
-
 interface InfiniteTableSetupState<T> {
+    renderer: ReactHeadlessTableRenderer;
+    onRenderUpdater: SubscriptionCallback<Renderable>;
     propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
     columnsWhenInlineGroupRenderStrategy?: Map<string, InfiniteTableColumn<T>>;
     domRef: MutableRefObject<HTMLDivElement | null>;
     scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
     portalDOMRef: MutableRefObject<HTMLDivElement | null>;
     onRowHeightCSSVarChange: SubscriptionCallback<number>;
-    onHeaderHeightCSSVarChange: SubscriptionCallback<number>;
+    onColumnHeaderHeightCSSVarChange: SubscriptionCallback<number>;
     columnsWhenGrouping?: InfiniteTablePropColumnsMap<T>;
     bodySize: Size;
     brain: MatrixBrain;
@@ -424,6 +507,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'];
@@ -435,11 +519,14 @@ interface InfiniteTableMappedState<T> {
     onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
     onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
     autoSizeColumnsKey: InfiniteTableProps<T>['autoSizeColumnsKey'];
+    activeRowIndex: number | null;
+    activeCellIndex: [number, number] | null;
     scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
     onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
     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'];
@@ -453,7 +540,6 @@ interface InfiniteTableMappedState<T> {
     pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
     pivotColumn: InfiniteTableProps<T>['pivotColumn'];
     pivotColumnGroups: InfiniteTablePropColumnGroupsMap;
-    activeIndex: NonUndefined<InfiniteTableProps<T>['activeIndex']>;
     columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
     columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
     columnDefaultWidth: NonUndefined<InfiniteTableProps<T>['columnDefaultWidth']>;
@@ -467,7 +553,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;
@@ -481,13 +567,14 @@ interface InfiniteTableMappedState<T> {
 interface InfiniteTableDerivedState<T> {
     groupBy: DataSourceProps<T>['groupBy'];
     computedColumns: Map<string, InfiniteTableColumn<T>>;
+    enableKeyboardNavigation: boolean;
     groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
     columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
     columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
     columnGroupsMaxDepth: number;
     computedColumnGroups: InfiniteTablePropColumnGroupsMap;
     rowHeightCSSVar: string;
-    headerHeightCSSVar: string;
+    columnHeaderHeightCSSVar: string;
     controlledColumnVisibility: boolean;
 }
 declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
@@ -519,9 +606,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'];
@@ -532,10 +623,12 @@ declare type InfiniteTableColumnType<T> = {
     verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
     cssEllipsis?: boolean;
     headerCssEllipsis?: boolean;
+    field?: keyof T;
     components?: InfiniteTableColumn<T>['components'];
     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>>;
@@ -550,6 +643,18 @@ declare type InfiniteTableImperativeApi<T> = {
     setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
     setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
     x?: T;
+    scrollRowIntoView: (rowIndex: number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => void;
+    scrollColumnIntoView: (colId: string, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => void;
+    scrollCellIntoView: (rowIndex: number, colIdOrIndex: string | number, config?: {
+        scrollAdjustPosition?: ScrollAdjustPosition;
+        offset?: number;
+    }) => void;
     getState: () => InfiniteTableState<T>;
     getDataSourceState: () => DataSourceState<T>;
 };
@@ -609,6 +714,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>>;
@@ -642,13 +756,20 @@ 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;
+    defaultActiveRowIndex?: number | null;
+    activeRowIndex?: number | null;
+    onActiveRowIndexChange?: (activeRowIndex: number) => void;
+    onActiveCellIndexChange?: (activeCellIndex: [number, number]) => void;
+    activeCellIndex?: [number, number] | null;
+    defaultActiveCellIndex?: [number, number] | null;
     draggableColumns?: boolean;
     header?: boolean;
+    headerOptions?: InfiniteTablePropHeaderOptions;
     focusedClassName?: string;
     focusedWithinClassName?: string;
     focusedStyle?: React$1.CSSProperties;
@@ -661,8 +782,6 @@ interface InfiniteTableProps<T> {
     resizableColumns?: boolean;
     virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
     virtualizeRows?: boolean;
-    defaultActiveIndex?: number;
-    activeIndex?: number;
     onSelfFocus?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
     onSelfBlur?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
     onFocusWithin?: (event: React$1.FocusEvent<HTMLDivElement>) => void;
@@ -676,12 +795,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[];
@@ -692,12 +815,14 @@ declare type Scrollbars = {
     vertical: boolean;
     horizontal: boolean;
 };
+declare type ScrollAdjustPosition = 'start' | 'end' | 'center';
 
 interface InfiniteTableComputedValues<T> {
     scrollbars: {
         vertical: boolean;
         horizontal: boolean;
     };
+    showColumnFilters: boolean;
     rowspan?: MatrixBrainOptions['rowspan'];
     computedPinnedStartOverflow: boolean;
     computedPinnedEndOverflow: boolean;
@@ -728,216 +853,208 @@ 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;
+    rowActive: boolean;
+    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;
-};
-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;
+    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 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;
@@ -959,10 +1076,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
@@ -988,6 +1109,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.
@@ -1182,177 +1304,292 @@ 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 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 const multisort: {
+    <T>(sortInfo: MultisortInfo<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
 };
 
-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 RenderRange = {
+    renderStartIndex: number;
+    renderEndIndex: number;
 };
-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'];
+
+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 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 DataSourceGroupBy<T> = GroupBy<T, any>;
+declare type DataSourcePivotBy<T> = PivotBy<T, any>;
+declare type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
+declare type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
+declare type DataSourceRemoteData<T> = {
+    data: T[] | LazyGroupDataItem<T>[];
+    mappings?: DataSourceMappings;
+    cache?: boolean;
+    error?: string;
+    totalCount?: number;
+    totalCountUnfiltered?: number;
+    livePaginationCursor?: DataSourceLivePaginationCursorValue;
 };
-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 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 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 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'];
+    sortMode: DataSourceProps<T>['sortMode'];
+    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;
+    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 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<{
+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>;
+    };
+};
+declare type LazyRowInfoGroup<DataType> = {
     /**
-     * Determines the field property of the column.
+     * Those are direct children of the current lazy group row
      */
-    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>>;
+    children: LazyGroupDataItem<DataType>[];
+    childrenLoading: boolean;
+    childrenAvailable: boolean;
+    cache: boolean;
+    totalCount: number;
+    totalCountUnfiltered: number;
+    error?: string;
+};
+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>;
+    sortMode?: 'local' | 'remote';
+    filterMode?: 'local' | 'remote';
+    filterValue?: DataSourcePropFilterValue<T>;
+    defaultFilterValue?: DataSourcePropFilterValue<T>;
+    onFilterValueChange?: (filterValue: DataSourcePropFilterValue<T>) => void;
+    filterDelay?: number;
+    filterTypes?: DataSourcePropFilterTypes<T>;
+    sortTypes?: DataSourcePropSortTypes;
 };
-/**
- * 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 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 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 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 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 DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T>) => any;
+declare type DataSourceFilterType<T> = {
+    emptyValues: Set<any>;
+    label?: string;
+    defaultOperator: string;
+    operators: DataSourceFilterOperator<T>[];
 };
-declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
-declare type InfiniteTableComputedColumnBase<T> = {
-    computedWidth: number;
-    computedOffset: number;
-    computedPinningOffset: number;
-    computedAbsoluteOffset: number;
-    computedSortable: boolean;
-    computedSortInfo: DataSourceSingleSortInfo<T> | null;
-    computedSorted: boolean;
-    computedSortedAsc: boolean;
-    computedSortedDesc: boolean;
-    computedSortIndex: number;
-    computedVisibleIndex: number;
-    computedMultiSort: boolean;
-    computedPinned: InfiniteTableColumnPinnedValues;
-    computedDraggable: boolean;
-    computedFirstInCategory: boolean;
-    computedLastInCategory: boolean;
-    computedFirst: boolean;
-    computedLast: boolean;
-    toggleSort: () => void;
-    id: string;
+declare type DataSourceFilterOperator<T> = {
+    name: string;
+    label?: string;
+    fn: DataSourceFilterOperatorFunction<T>;
 };
-declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
-declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<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>>;
 
@@ -1364,10 +1601,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;
@@ -1423,4 +1662,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, DataSourcePropSortInfo, 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 };