@infinite-table/infinite-react 0.4.1 → 0.4.4

package/index.d.ts

@@ -1,10 +1,42 @@
 import * as React$1 from 'react';
 import { CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, KeyboardEvent } from 'react';
 
+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 MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
+    field?: keyof T | (keyof T)[];
+};
+declare const multisort: {
+    <T>(sortInfo: MultisortInfoAllowMultipleFields<T>[], array: T[], get?: ((item: any) => T) | undefined): T[];
+    knownTypes: {
+        [key: string]: (first: any, second: any) => number;
+    };
+};
+
 declare type VoidFn$1 = () => void;
 declare type Pair<KeyType, ValueType> = {
     value?: ValueType;
     map?: Map<KeyType, Pair<KeyType, ValueType>>;
+    length: number;
     revision?: number;
 };
 declare type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn$1) => void;
@@ -16,9 +48,11 @@ declare class DeepMap<KeyType, ValueType> {
     static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
     constructor(initial?: [KeyType[], ValueType][]);
     fill(initial?: [KeyType[], ValueType][]): void;
-    getValuesStartingWith(keys: KeyType[]): ValueType[];
-    getKeysStartingWith(keys: KeyType[]): KeyType[][];
+    getValuesStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): ValueType[];
+    getKeysStartingWith(keys: KeyType[], excludeSelf?: boolean, depthLimit?: number): KeyType[][];
     private getStartingWith;
+    private getMapAt;
+    getAllChildrenSizeFor(keys: KeyType[]): number;
     getDirectChildrenSizeFor(keys: KeyType[]): number;
     set(keys: KeyType[] & {
         length: Omit<number, 0>;
@@ -33,6 +67,7 @@ declare class DeepMap<KeyType, ValueType> {
     visitDepthFirst: (fn: (value: ValueType, keys: KeyType[], indexInGroup: number, next?: VoidFn$1 | undefined) => void) => void;
     private visitWithNext;
     private getArray;
+    valuesAt(keys: KeyType[]): ValueType[];
     values(): Generator<ValueType, void, unknown>;
     keys(): Generator<KeyType[], void, unknown>;
     entries(): Generator<[KeyType[], ValueType], void, unknown>;
@@ -42,34 +77,6 @@ declare class DeepMap<KeyType, ValueType> {
     private sortedIterator;
 }
 
-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 ComponentStateContext<T_STATE, T_ACTIONS> = {
     getComponentState: () => T_STATE;
     componentState: T_STATE;
@@ -87,7 +94,7 @@ declare type ComponentInterceptedActions<T_STATE> = {
 declare type ComponentMappedCallbacks<T_STATE> = {
     [k in keyof T_STATE]: (value: T_STATE[k], state: T_STATE) => {
         callbackName: string;
-        callbackParam: any;
+        callbackParams: any[];
     };
 };
 declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
@@ -111,7 +118,7 @@ declare type InfiniteTableAction = {
 
 declare type Renderable = React$1.ReactNode | JSX.Element;
 
-declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParams<T, InfiniteTableComputedColumn<T>>;
+declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParam<T, InfiniteTableComputedColumn<T>>;
 
 declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
 
@@ -132,6 +139,7 @@ interface Size {
 
 declare type InfiniteTableBaseCellProps<T> = {
     column: InfiniteTableComputedColumn<T>;
+    rowId?: any;
     renderChildren: () => Renderable;
     width: number;
     cssEllipsis?: boolean;
@@ -158,13 +166,22 @@ declare type DiscriminatedUnion<A, B> = (A & {
 
 declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
 declare type InfiniteTableSelectRowFn = (id: any) => void;
-declare type InfiniteTableColumnHeaderParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
+declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
     domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
-    sortTool: JSX.Element | null;
     dragging: boolean;
     column: COL_TYPE;
+    columnsMap: Map<string, COL_TYPE>;
     columnSortInfo: DataSourceSingleSortInfo<DATA_TYPE> | null;
     columnFilterValue: DataSourceFilterValueItem<DATA_TYPE> | null;
+    selectionMode: DataSourcePropSelectionMode;
+    allRowsSelected: boolean;
+    someRowsSelected: boolean;
+    api: InfiniteTableApi<DATA_TYPE>;
+    renderBag: {
+        header: string | number | Renderable;
+        sortIcon?: Renderable;
+        selectionCheckBox?: Renderable;
+    };
 };
 declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
     domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
@@ -174,10 +191,12 @@ declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTa
         groupIcon?: Renderable;
         selectionCheckBox?: Renderable;
     };
-    groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
     rowIndex: number;
     rowActive: boolean;
+    api: InfiniteTableApi<DATA_TYPE>;
     column: COL_TYPE;
+    columnsMap: Map<string, COL_TYPE>;
+    groupByColumn?: InfiniteTableComputedColumn<DATA_TYPE>;
     toggleCurrentGroupRow: () => void;
     toggleGroupRow: InfiniteTableToggleGroupRowFn;
     toggleCurrentGroupRowSelection: () => void;
@@ -187,7 +206,7 @@ declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTa
     deselectCurrentRow: () => void;
     toggleRowSelection: InfiniteTableSelectRowFn;
     selectionMode: DataSourcePropSelectionMode | undefined;
-    groupBy: DataSourceState<DATA_TYPE>['groupBy'];
+    rootGroupBy: DataSourceState<DATA_TYPE>['groupBy'];
     pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
 };
 declare type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
@@ -204,7 +223,7 @@ declare type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE =
     isGroupRow: true;
 }) => Renderable | null;
 declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
-declare type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParams<T>) => Renderable;
+declare type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
 declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
 declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
 declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
@@ -212,11 +231,11 @@ declare type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
 declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
 declare type InfiniteTableColumnStyleFnParams<T> = {
     value: Renderable;
-    column: InfiniteTableColumn<T>;
+    column: InfiniteTableComputedColumn<T>;
 } & InfiniteTableRowInfoDataDiscriminator<T>;
 declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
-declare type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParams<T>) => undefined | string;
-declare type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParams<T>) => undefined | React.CSSProperties;
+declare type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
+declare type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React.CSSProperties;
 declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
 declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
 declare type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
@@ -231,18 +250,26 @@ declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | numb
 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> = {
+/**
+ * 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> = {
     sortable?: boolean;
     draggable?: boolean;
     resizable?: boolean;
-    comparer?: InfiniteTableColumnComparer<T>;
-    defaultHiddenWhenGroupedBy?: '*' | keyof T | {
-        [k in keyof Partial<T>]: true;
+    comparer?: InfiniteTableColumnComparer<DATA_TYPE>;
+    defaultHiddenWhenGroupedBy?: '*' | true | keyof DATA_TYPE | {
+        [k in keyof Partial<DATA_TYPE>]: true;
     };
     align?: InfiniteTableColumnAlign;
     verticalAlign?: InfiniteTableColumnVerticalAlign;
     columnGroup?: string;
-    header?: InfiniteTableColumnHeader<T>;
+    header?: InfiniteTableColumnHeader<DATA_TYPE>;
+    renderHeader?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
     name?: Renderable;
     cssEllipsis?: boolean;
     headerCssEllipsis?: boolean;
@@ -250,39 +277,33 @@ declare type InfiniteTableBaseColumn<T> = {
     dataType?: InfiniteTableDataTypeNames;
     sortType?: string;
     filterType?: string;
-    style?: InfiniteTableColumnStyle<T>;
-    headerStyle?: InfiniteTableColumnHeaderStyle<T>;
-    headerClassName?: InfiniteTableColumnHeaderClassName<T>;
-    className?: InfiniteTableColumnClassName<T>;
-    rowspan?: InfiniteTableColumnRowspanFn<T>;
-    field?: keyof T;
-    render?: InfiniteTableColumnRenderFunction<T>;
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
-    renderGroupValue?: InfiniteTableColumnRenderFunction<T>;
-    renderLeafValue?: InfiniteTableColumnRenderFunction<T>;
-    valueGetter?: InfiniteTableColumnValueGetter<T>;
-    valueFormatter?: InfiniteTableColumnValueFormatter<T>;
+    style?: InfiniteTableColumnStyle<DATA_TYPE>;
+    headerStyle?: InfiniteTableColumnHeaderStyle<DATA_TYPE>;
+    headerClassName?: InfiniteTableColumnHeaderClassName<DATA_TYPE>;
+    className?: InfiniteTableColumnClassName<DATA_TYPE>;
+    rowspan?: InfiniteTableColumnRowspanFn<DATA_TYPE>;
+    field?: keyof DATA_TYPE;
+    render?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderValue?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderGroupValue?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderLeafValue?: InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    valueGetter?: InfiniteTableColumnValueGetter<DATA_TYPE>;
+    valueFormatter?: InfiniteTableColumnValueFormatter<DATA_TYPE>;
     defaultWidth?: number;
     defaultFlex?: number;
     defaultFilterable?: boolean;
     minWidth?: number;
     maxWidth?: number;
-    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<T>;
-    renderSelectionCheckBox?: boolean | InfiniteTableColumnRenderFunction<T>;
+    renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE>;
+    renderSortIcon?: InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
+    renderSelectionCheckBox?: boolean | InfiniteTableColumnRenderFunction<DATA_TYPE>;
+    renderHeaderSelectionCheckBox?: boolean | InfiniteTableColumnHeaderRenderFunction<DATA_TYPE>;
     components?: {
         ColumnCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
         HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
     };
 };
-/**
- * Defines a column in the table.
- *
- * @typeParam DATA_TYPE The type of the data in the table.
- *
- * Can be bound to a field which is a `keyof DATA_TYPE`.
- */
-declare type InfiniteTableColumn<DATA_TYPE> = {} & InfiniteTableBaseColumn<DATA_TYPE>;
-declare type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
+declare type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'sortable'> & {
     groupByField: string | string[];
     id?: string;
 };
@@ -324,6 +345,7 @@ declare type InfiniteTableComputedColumnBase<T> = {
     computedSortedAsc: boolean;
     computedSortedDesc: boolean;
     computedSortIndex: number;
+    computedVisible: boolean;
     computedVisibleIndex: number;
     computedVisibleIndexInCategory: number;
     computedMultiSort: boolean;
@@ -338,6 +360,7 @@ declare type InfiniteTableComputedColumnBase<T> = {
     computedFirst: boolean;
     computedLast: boolean;
     toggleSort: () => void;
+    colType: InfiniteTableColumnType<T>;
     id: string;
 };
 declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
@@ -619,12 +642,142 @@ declare class MatrixBrain extends Logger {
     destroy: () => void;
 }
 
+declare type RowSelectionStateItem = (any | any[])[];
+declare type RowSelectionStateObject = {
+    selectedRows: RowSelectionStateItem;
+    deselectedRows: RowSelectionStateItem;
+    defaultSelection: boolean;
+} | {
+    defaultSelection: true;
+    deselectedRows: RowSelectionStateItem;
+    selectedRows?: RowSelectionStateItem;
+} | {
+    defaultSelection: false;
+    selectedRows: RowSelectionStateItem;
+    deselectedRows?: RowSelectionStateItem;
+};
+declare type RowSelectionStateConfig<T> = {
+    groupBy: DataSourceState<T>['groupBy'];
+    groupDeepMap: DataSourceState<T>['groupDeepMap'];
+    totalCount: number;
+    indexer: DataSourceState<T>['indexer'];
+    lazyLoad: boolean;
+};
+declare type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
+declare type RowSelectionStateOverrideForTesting = {
+    getGroupKeysForPrimaryKey: RowSelectionState<any>['getGroupKeysForPrimaryKey'];
+    getGroupByLength: RowSelectionState<any>['getGroupByLength'];
+    getGroupCount: RowSelectionState<any>['getGroupCount'];
+    getGroupKeysDirectlyInsideGroup: RowSelectionState<any>['getGroupKeysDirectlyInsideGroup'];
+};
+declare class RowSelectionState<T = any> {
+    selectedRows: RowSelectionStateItem | null;
+    deselectedRows: RowSelectionStateItem | null;
+    defaultSelection: boolean;
+    selectedMap: DeepMap<any, true>;
+    deselectedMap: DeepMap<any, true>;
+    selectionCache: DeepMap<any, boolean | null>;
+    selectionCountCache: DeepMap<any, {
+        selectedCount: number;
+        deselectedCount: number;
+    }>;
+    getConfig: GetRowSelectionStateConfig<T>;
+    getGroupKeysForPrimaryKey(pk: any): any[];
+    getGroupDeepMap(): DeepMap<any, DeepMapGroupValueType<T, any>> | undefined;
+    getGroupCount(groupKeys: any[]): number;
+    getGroupKeysDirectlyInsideGroup(groupKeys: any[]): any[][];
+    getGroupByLength(): number;
+    static from<T>(rowSeleStateObject: RowSelectionStateObject, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverrideForTesting): RowSelectionState<T>;
+    constructor(state: RowSelectionStateObject | RowSelectionState, getConfig: GetRowSelectionStateConfig<T>, _forTestingOnly?: RowSelectionStateOverrideForTesting);
+    mapSet: (name: 'selected' | 'deselected', key: any | any[]) => void;
+    _selectedMapSet: (key: any | any[]) => void;
+    _deselectedMapSet: (key: any | any[]) => void;
+    update(stateObject: RowSelectionStateObject): void;
+    private xcache;
+    getState(): RowSelectionStateObject;
+    deselectAll(): void;
+    selectAll(): void;
+    isRowDefaultSelected(): boolean;
+    isRowDefaultDeselected(): boolean;
+    /**
+     *
+     * @param key the id of the row - if a row in a grouped datasource, this is the final row id, without the group keys
+     * @param groupKeys the keys of row parents, in order
+     * @returns Whether the row is selected or not.
+     */
+    isRowSelected(key: any, groupKeys?: any[]): boolean;
+    isRowDeselected(key: any, groupKeys?: any[]): boolean;
+    setRowSelected(key: string | number, selected: boolean, groupKeys?: any[]): void;
+    /**
+     * Returns if the selection state ('full','partial','none') for the current group
+     *
+     * The selection state will be full (true) if either of those are true:
+     *  * the group keys are specified as selected
+     *  * all the children are specified as selected
+     *
+     * The selection state will be partial (null) if either of those are true:
+     *  * the group keys are partially selected
+     *  * some of the children are specified as selected
+     *
+     *
+     * @param groupKeys the keys of the group row
+     * @param children leaf children that belong to the group
+     * @returns boolean
+     */
+    getGroupRowSelectionState(initialGroupKeys: any[]): boolean | null;
+    private getGroupRowBooleanSelectionStateFromParent;
+    isGroupRowPartlySelected(groupKeys: any[]): boolean;
+    isGroupRowSelected(groupKeys: any[]): boolean;
+    isGroupRowDeselected(groupKeys: any[]): boolean;
+    selectGroupRow(groupKeys: any[]): void;
+    deselectGroupRow(groupKeys: any[]): void;
+    setRowAsSelected(key: string | number, groupKeys?: any[]): void;
+    setRowAsDeselected(key: string | number, groupKeys?: any[]): void;
+    deselectRow(key: any, groupKeys?: any[]): void;
+    selectRow(key: any, groupKeys?: any[]): void;
+    toggleGroupRowSelection(groupKeys: any[]): void;
+    toggleRowSelection(key: string | number, groupKeys?: any[] | undefined): void;
+    getSelectedCount(): number;
+    getDeselectedCount(): number;
+    getSelectionCountFor(groupKeys?: any[], parentSelected?: boolean): {
+        selectedCount: number;
+        deselectedCount: number;
+    };
+}
+
+declare type MultiRowSelectorOptions = {
+    getIdForIndex: (index: number) => string | number;
+};
+declare class MultiRowSelector {
+    getIdForIndex: MultiRowSelectorOptions['getIdForIndex'];
+    multiSelectStartIndex: number;
+    multiSelectEndIndex?: number;
+    _rowSelectionState: RowSelectionState;
+    constructor(options: MultiRowSelectorOptions);
+    set rowSelectionState(rowSelectionState: RowSelectionState);
+    get rowSelectionState(): RowSelectionState;
+    private selectRange;
+    private deselectRange;
+    /**
+     * This is the single click, without any modifier
+     */
+    resetClick(index: number): void;
+    /**
+     * This is the click with ctrl/cmd key pressed
+     * @param index
+     */
+    singleAddClick(index: number): void;
+    multiSelectClick(index: number): void;
+}
+
 interface InfiniteTableComputedValues<T> {
     scrollbars: {
         vertical: boolean;
         horizontal: boolean;
     };
+    multiRowSelector: MultiRowSelector;
     showColumnFilters: boolean;
+    renderSelectionCheckBox: boolean;
     rowspan?: MatrixBrainOptions['rowspan'];
     computedPinnedStartOverflow: boolean;
     computedPinnedEndOverflow: boolean;
@@ -633,6 +786,7 @@ interface InfiniteTableComputedValues<T> {
     computedUnpinnedColumns: InfiniteTableComputedColumn<T>[];
     computedVisibleColumns: InfiniteTableComputedColumn<T>[];
     computedVisibleColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
+    computedColumnsMap: Map<string, InfiniteTableComputedColumn<T>>;
     computedColumnVisibility: InfiniteTablePropColumnVisibility;
     computedColumnOrder: InfiniteTablePropColumnOrderNormalized;
     computedPinnedStartColumnsWidth: number;
@@ -778,6 +932,9 @@ interface InfiniteTableSetupState<T> {
     cellClick: SubscriptionCallback<CellPosition & {
         event: MouseEvent;
     }>;
+    cellMouseDown: SubscriptionCallback<CellPosition & {
+        event: MouseEvent;
+    }>;
     keyDown: SubscriptionCallback<KeyboardEvent>;
     columnsWhenGrouping?: InfiniteTableColumnsMap<T>;
     bodySize: Size;
@@ -840,6 +997,8 @@ interface InfiniteTableMappedState<T> {
     draggableColumns: NonUndefined<InfiniteTableProps<T>['draggableColumns']>;
     sortable: NonUndefined<InfiniteTableProps<T>['sortable']>;
     hideEmptyGroupColumns: NonUndefined<InfiniteTableProps<T>['hideEmptyGroupColumns']>;
+    hideColumnWhenGrouped: NonUndefined<InfiniteTableProps<T>['hideColumnWhenGrouped']>;
+    keyboardSelection: NonUndefined<InfiniteTableProps<T>['keyboardSelection']>;
     columnOrder: NonUndefined<InfiniteTableProps<T>['columnOrder']>;
     showZebraRows: NonUndefined<InfiniteTableProps<T>['showZebraRows']>;
     showHoverRows: NonUndefined<InfiniteTableProps<T>['showHoverRows']>;
@@ -859,6 +1018,7 @@ interface InfiniteTableMappedState<T> {
 interface InfiniteTableDerivedState<T> {
     groupBy: DataSourceProps<T>['groupBy'];
     computedColumns: Map<string, InfiniteTableColumn<T>>;
+    initialColumns: InfiniteTableProps<T>['columns'];
     groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
     columnHeaderCssEllipsis: NonUndefined<InfiniteTableProps<T>['columnHeaderCssEllipsis']>;
     keyboardNavigation: NonUndefined<InfiniteTableProps<T>['keyboardNavigation']>;
@@ -874,7 +1034,7 @@ interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTab
 }
 
 interface InfiniteTableContextValue<T> {
-    imperativeApi: InfiniteTableImperativeApi<T>;
+    imperativeApi: InfiniteTableApi<T>;
     componentState: InfiniteTableState<T>;
     componentActions: InfiniteTableActions<T>;
     computed: InfiniteTableComputedValues<T>;
@@ -887,70 +1047,59 @@ declare type RenderRange = {
     renderEndIndex: number;
 };
 
-declare class Indexer<PrimaryKeyType = string> {
-    indexToPrimaryKey: Map<number, PrimaryKeyType>;
-    primaryKeyToIndex: Map<string, number>;
-    add(index: number, primaryKey: PrimaryKeyType): void;
-    clear(): void;
-    getIndexOf(primaryKey: PrimaryKeyType): number | undefined;
-    getPrimaryKeyFor(index: number): PrimaryKeyType | undefined;
-}
-
-declare type BooleanCollectionStateKeys<KeyType extends string | number> = true | Record<KeyType, true>;
-declare type BooleanCollectionStateObject<KeyType extends string | number> = {
-    positiveItems: BooleanCollectionStateKeys<KeyType>;
-    negativeItems: BooleanCollectionStateKeys<KeyType>;
-};
-declare abstract class BooleanCollectionState<StateObject, KeyType extends string | number = string> {
-    protected positiveMap?: Map<KeyType, true>;
-    protected negativeMap?: Map<KeyType, true>;
+declare type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
+declare type BooleanDeepCollectionStateObject<KeyType> = {
+    positiveItems: BooleanDeepCollectionStateKeys<KeyType>;
+    negativeItems: BooleanDeepCollectionStateKeys<KeyType>;
+};
+declare abstract class BooleanDeepCollectionState<StateObject, KeyType extends any = any> {
+    protected positiveMap?: DeepMap<KeyType, true>;
+    protected negativeMap?: DeepMap<KeyType, true>;
     protected allNegative: boolean;
     protected allPositive: boolean;
     private initialState;
-    constructor(state: BooleanCollectionStateObject<KeyType> | BooleanCollectionState<StateObject, KeyType>);
-    abstract getPositiveFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
-    abstract getNegativeFromState(state: StateObject): BooleanCollectionStateKeys<KeyType>;
+    constructor(state: BooleanDeepCollectionStateObject<KeyType> | BooleanDeepCollectionState<StateObject, KeyType>);
+    abstract getPositiveFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
+    abstract getNegativeFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
     abstract getState(): StateObject;
-    protected getInitialState(): BooleanCollectionStateObject<KeyType>;
+    protected getInitialState(): BooleanDeepCollectionStateObject<KeyType>;
     destroy(): void;
     private update;
-    protected isDefaultNegativeSelection(): boolean;
-    protected isDefaultPositiveSelection(): boolean;
     protected areAllNegative(): boolean;
     protected areAllPositive(): boolean;
     protected makeAllNegative(): void;
     protected makeAllPositive(): void;
-    protected isItemPositive(key: KeyType): boolean;
-    protected isItemNegative(key: KeyType): boolean;
-    protected setItemValue(key: KeyType, shouldMakePositive: boolean): void;
-    protected makeItemNegative(key: KeyType): void;
-    protected makeItemPositive(key: KeyType): void;
-    protected toggleItem(key: KeyType): void;
+    protected isItemPositive(keys: KeyType[]): boolean | undefined;
+    protected isItemNegative(keys: KeyType[]): boolean;
+    protected setItemValue(keys: KeyType[], shouldMakePositive: boolean): void;
+    protected makeItemNegative(keys: KeyType[]): void;
+    protected makeItemPositive(keys: KeyType[]): void;
+    protected toggleItem(keys: KeyType[]): void;
 }
 
-declare type RowSelectionStateKeys<RowKeyType extends string | number> = true | Record<RowKeyType, true>;
-declare type RowSelectionStateObject<RowKeyType extends string | number = string> = {
-    selectedRows: RowSelectionStateKeys<RowKeyType>;
-    deselectedRows: RowSelectionStateKeys<RowKeyType>;
-};
-declare class RowSelectionState<RowKeyType extends string | number = string> extends BooleanCollectionState<RowSelectionStateObject<RowKeyType>, RowKeyType> {
-    constructor(state: RowSelectionStateObject<RowKeyType> | RowSelectionState<RowKeyType>);
-    getState(): RowSelectionStateObject<RowKeyType>;
-    getPositiveFromState(state: RowSelectionStateObject<RowKeyType>): RowSelectionStateKeys<RowKeyType>;
-    getNegativeFromState(state: RowSelectionStateObject<RowKeyType>): RowSelectionStateKeys<RowKeyType>;
-    areAllSelected(): boolean;
-    areAllDeselected(): boolean;
-    deselectAll(): void;
-    selectAll(): void;
-    isRowDefaultSelected(): boolean;
-    isRowDefaultDeselected(): boolean;
-    isRowSelected(key: string | number): boolean;
-    isRowDeselected(key: string | number): boolean;
-    setRowSelected(key: string | number, selected: boolean): void;
-    deselectRow(key: string | number): void;
-    selectRow(key: string | number): void;
-    toggleRowSelection(key: string | number): void;
-    getSelectedCount(maxCount?: number): number;
+declare class GroupRowsState<KeyType extends any = any> extends BooleanDeepCollectionState<DataSourcePropGroupRowsStateObject<KeyType>, KeyType> {
+    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
+    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
+    getPositiveFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
+    getNegativeFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
+    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 class Indexer<DataType, PrimaryKeyType = string> {
+    primaryKeyToData: Map<string, DataType>;
+    add: (primaryKey: PrimaryKeyType, data: DataType) => void;
+    clear: () => void;
+    getDataForPrimaryKey: (primaryKey: PrimaryKeyType) => DataType | undefined;
+    indexArray: (arr: DataType[], toPrimaryKey: (data: DataType) => PrimaryKeyType) => void;
 }
 
 interface DataSourceDataParams<T> {
@@ -970,8 +1119,8 @@ interface DataSourceDataParams<T> {
     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;
+declare type DataSourceSingleSortInfo<T> = Omit<MultisortInfo<T>, 'field'> & {
+    field?: keyof T | (keyof T)[];
     id?: string;
 };
 declare type DataSourceGroupBy<T> = GroupBy<T, any>;
@@ -1021,7 +1170,7 @@ declare type DataSourceAggregationReducer<T, AggregationResultType> = {
     field?: keyof T;
     initialValue?: AggregationResultType;
     getter?: (data: T) => any;
-    reducer: string | ((accumulator: any, value: any, data: T, index: number) => AggregationResultType | any);
+    reducer: string | ((accumulator: any, value: any, data: T, index: number, groupKeys: any[] | undefined) => AggregationResultType | any);
     done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
     pivotColumn?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<T>>> | (({ column, }: {
         column: InfiniteTablePivotFinalColumnVariant<T>;
@@ -1036,6 +1185,7 @@ declare type LazyGroupDataItem<DataType> = {
     keys: any[];
     aggregations?: Record<string, any>;
     dataset?: DataSourceRemoteData<DataType>;
+    totalChildrenCount?: number;
     pivot?: {
         values: Record<string, any>;
         totals?: Record<string, any>;
@@ -1055,7 +1205,7 @@ declare type LazyRowInfoGroup<DataType> = {
 };
 declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
 interface DataSourceSetupState<T> {
-    indexer: Indexer;
+    indexer: Indexer<T, any>;
     unfilteredCount: number;
     filteredCount: number;
     lazyLoadCacheOfLoadedBatches: DeepMap<string, true>;
@@ -1077,7 +1227,7 @@ interface DataSourceSetupState<T> {
     groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
     reducerResults?: Record<string, AggregationReducerResult>;
     allRowsSelected: boolean;
-    selectedRowCount: number;
+    someRowsSelected: boolean;
     pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
     pivotGrandTotalColumnPosition: InfiniteTablePropPivotGrandTotalColumnPosition;
     cursorId: number | symbol | DataSourceLivePaginationCursorValue;
@@ -1096,33 +1246,23 @@ interface DataSourceSetupState<T> {
 declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
 declare type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
 declare type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
-declare type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject | RowSelectionState;
+declare type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
 declare type DataSourcePropRowSelection_SingleRow = null | string | number;
 declare type DataSourcePropCellSelection = any;
 declare type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
-declare type DataSourcePropOnRowSelectionChange_MultiRow = (params: {
-    rowSelection: DataSourcePropRowSelection_MultiRow;
-    rowSelectionState: RowSelectionState;
-    selectionMode: 'multi-row';
-}) => void;
-declare type DataSourcePropOnRowSelectionChange_SingleRow = (params: {
-    rowSelection: DataSourcePropRowSelection_SingleRow;
-    selectionMode: 'single-row';
-}) => void;
+declare type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
+declare type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
 declare type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
 declare type DataSourcePropOnCellSelectionChange = (cellSelectionParams: any) => void;
-declare type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelection: DataSourcePropRowSelection, selectionMode: DataSourcePropSelectionMode) => boolean;
+declare type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
 declare type DataSourceProps<T> = {
     children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
-    primaryKey: keyof T | (({ data, index }: {
-        data: T;
-        index: number;
-    }) => string);
+    primaryKey: keyof T | ((data: T) => string);
     fields?: (keyof T)[];
     data: DataSourceData<T>;
     selectionMode?: DataSourcePropSelectionMode;
-    rowSelection?: DataSourcePropRowSelection;
-    defaultRowSelection?: DataSourcePropRowSelection;
+    rowSelection?: DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
+    defaultRowSelection?: DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
     cellSelection?: DataSourcePropCellSelection;
     defaultCellSelection?: DataSourcePropCellSelection;
     onCellSelectionChange?: DataSourcePropOnCellSelectionChange;
@@ -1230,14 +1370,14 @@ interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedS
 declare type DataSourceDerivedState<T> = {
     toPrimaryKey: (data: T) => any;
     operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
-    rowSelection: RowSelectionState | null | number | string;
-    selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
     filterMode: NonUndefined<DataSourceProps<T>['filterMode']>;
     multiSort: boolean;
     controlledSort: boolean;
     controlledFilter: boolean;
     livePaginationCursor?: DataSourceLivePaginationCursorValue;
     lazyLoadBatchSize?: number;
+    rowSelection: RowSelectionState | null | number | string;
+    selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
 };
 declare type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
 interface DataSourceContextValue<T> {
@@ -1256,52 +1396,11 @@ interface DataSourceReducer<T> {
     (state: DataSourceState<T>, action: DataSourceAction<any>): DataSourceState<T>;
 }
 
-declare type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
-declare type BooleanDeepCollectionStateObject<KeyType> = {
-    positiveItems: BooleanDeepCollectionStateKeys<KeyType>;
-    negativeItems: BooleanDeepCollectionStateKeys<KeyType>;
-};
-declare abstract class BooleanDeepCollectionState<StateObject, KeyType extends any = any> {
-    protected positiveMap?: DeepMap<KeyType, true>;
-    protected negativeMap?: DeepMap<KeyType, true>;
-    protected allNegative: boolean;
-    protected allPositive: boolean;
-    private initialState;
-    constructor(state: BooleanDeepCollectionStateObject<KeyType> | BooleanDeepCollectionState<StateObject, KeyType>);
-    abstract getPositiveFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
-    abstract getNegativeFromState(state: StateObject): BooleanDeepCollectionStateKeys<KeyType>;
-    abstract getState(): StateObject;
-    protected getInitialState(): BooleanDeepCollectionStateObject<KeyType>;
-    destroy(): void;
-    private update;
-    protected areAllNegative(): boolean;
-    protected areAllPositive(): boolean;
-    protected makeAllNegative(): void;
-    protected makeAllPositive(): void;
-    protected isItemPositive(keys: KeyType[]): boolean | undefined;
-    protected isItemNegative(keys: KeyType[]): boolean;
-    protected setItemValue(keys: KeyType[], shouldMakePositive: boolean): void;
-    protected makeItemNegative(keys: KeyType[]): void;
-    protected makeItemPositive(keys: KeyType[]): void;
-    protected toggleItem(keys: KeyType[]): void;
-}
+declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
 
-declare class GroupRowsState<KeyType extends any = any> extends BooleanDeepCollectionState<DataSourcePropGroupRowsStateObject<KeyType>, KeyType> {
-    constructor(state: DataSourcePropGroupRowsStateObject<KeyType> | GroupRowsState<KeyType>);
-    getState(): DataSourcePropGroupRowsStateObject<KeyType>;
-    getPositiveFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
-    getNegativeFromState(state: DataSourcePropGroupRowsStateObject<KeyType>): DataSourceGroupRowsList<KeyType>;
-    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 function useDataSource<T>(): DataSourceState<T>;
+
+declare function DataSource<T>(props: DataSourceProps<T>): JSX.Element;
 
 declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
     id: string;
@@ -1326,6 +1425,7 @@ declare type InfiniteTableRowInfoDataDiscriminator<T> = {
     rowInfo: InfiniteTable_NoGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoNormal<T>;
     field?: keyof T;
     value: any;
+    rowSelected: boolean | null;
 } | {
     rowActive: boolean;
     data: Partial<T> | null;
@@ -1333,6 +1433,7 @@ declare type InfiniteTableRowInfoDataDiscriminator<T> = {
     isGroupRow: true;
     field?: keyof T;
     value: any;
+    rowSelected: boolean | null;
 };
 /**
  * This is the base row info for all scenarios - things every
@@ -1343,7 +1444,7 @@ declare type InfiniteTable_RowInfoBase<_T> = {
     id: any;
     value?: any;
     indexInAll: number;
-    rowSelected: boolean;
+    rowSelected: boolean | null;
 };
 declare type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
     dataSourceHasGrouping: true;
@@ -1354,10 +1455,6 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
     dataSourceHasGrouping: true;
     data: Partial<T> | null;
     isGroupRow: true;
-    /**
-     * The count of all selected leaf nodes (normal rows) inside the group that are selected
-     */
-    childrenSelectedCount: number;
     /**
      * This array contains all the (uncollapsed, so visible) row infos under this group, at any level of nesting,
      * in the order in which they are visible in the table
@@ -1375,6 +1472,23 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
      * The array of all leaf nodes (normal rows) that are inside this group.
      */
     groupData: T[];
+    /**
+     * The count of all selected leaf nodes (normal rows) inside the group that are selected
+     */
+    selectedChildredCount: number;
+    /**
+     * The count of all deselected leaf nodes (normal rows) inside the group that are selected
+     */
+    deselectedChildredCount: number;
+    /**
+     * Will be used only with lazy loading, if the server provides this info on the data items.
+     *
+     * Represents the total count of all leaf nodes (normal rows) that are under this group
+     * at any level (so not only direct children). This is needed for multiple selection to work properly,
+     * so the table component knows how many rows are on the remote backend, and whether to show a group as selected or not
+     * when it has a certain number of rows selected
+     */
+    totalChildrenCount?: number;
     /**
      * The count of all leaf nodes (normal rows) inside the group that are not being visible
      * due to collapsing (either the current row is collapsed or any of its children)
@@ -1524,6 +1638,7 @@ declare type DeepMapGroupValueType<DataType, KeyType> = {
     commonData?: Partial<DataType>;
     childrenLoading: boolean;
     childrenAvailable: boolean;
+    totalChildrenCount?: number;
     cache: boolean;
     error?: string;
     reducerResults: Record<string, AggregationReducerResult>;
@@ -1568,6 +1683,23 @@ declare type InfiniteCheckBoxProps = {
 };
 declare function InfiniteCheckBox(props: InfiniteCheckBoxProps): JSX.Element;
 
+declare type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
+declare type InfiniteTableSelectionApi = {
+    get allRowsSelected(): boolean;
+    isRowSelected(pk: any, groupKeys?: any[]): boolean;
+    isRowDeselected(pk: any, groupKeys?: any[]): boolean;
+    selectRow(pk: any, groupKeys?: any[]): void;
+    deselectRow(pk: any, groupKeys?: any[]): void;
+    toggleRowSelection(pk: any, groupKeys?: any[]): void;
+    selectGroupRow(groupKeys: any[], children?: ArrayOfIds): void;
+    deselectGroupRow(groupKeys: any[], children?: ArrayOfIds): void;
+    toggleGroupRowSelection(groupKeys: any[], children?: ArrayOfIds): void;
+    getGroupRowSelectionState(groupKeys: any[]): boolean | null;
+    getSelectedPrimaryKeys(): (string | number)[];
+    selectAll(): void;
+    deselectAll(): void;
+};
+
 declare type LoadMaskProps = {
     visible: boolean;
     children: Renderable;
@@ -1627,28 +1759,18 @@ declare type InfiniteTableColumnSizingOptions = {
     maxWidth?: number;
 };
 declare type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
-declare type InfiniteTableImperativeApi<T> = {
+declare type InfiniteTableApi<T> = {
+    get selectionApi(): InfiniteTableSelectionApi;
     setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
     setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
     x?: T;
-    get allRowsSelected(): boolean;
-    getSelectedRowCount(): number;
     get scrollLeft(): number;
     set scrollLeft(value: number);
     get scrollTop(): number;
     set scrollTop(value: number);
-    getSelectedRows: () => T[];
     toggleGroupRow: (groupKeys: any[]) => void;
-    toggleRowSelection: (pk: any) => boolean;
-    selectRow: (pk: any) => boolean;
-    isRowSelected: (pk: any) => boolean;
-    isGroupRowSelected: (groupKeys: any[]) => boolean;
-    toggleGroupRowSelection: (groupKeys: any[]) => boolean;
-    deselectRow: (pk: any) => boolean;
-    selectGroupRow: (groupKeys: any[]) => boolean;
-    deselectGroupRow: (groupKeys: any[]) => boolean;
-    selectAllRows: () => boolean;
-    deselectAllRows: () => boolean;
+    collapseGroupRow: (groupKeys: any[]) => boolean;
+    expandGroupRow: (groupKeys: any[]) => boolean;
     scrollRowIntoView: (rowIndex: number, config?: {
         scrollAdjustPosition?: ScrollAdjustPosition;
         offset?: number;
@@ -1695,6 +1817,7 @@ declare type InfiniteTableGroupColumnGetterOptions<T> = {
     groupCount: number;
     groupBy: DataSourceGroupBy<T>[];
     pivotBy?: DataSourcePivotBy<T>[];
+    sortable?: boolean;
 };
 declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
     column: COL_TYPE;
@@ -1703,7 +1826,6 @@ declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableCo
 };
 declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
 declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
-    renderValue?: InfiniteTableColumnRenderFunction<T>;
     renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<T>;
     id?: string;
 };
@@ -1771,6 +1893,7 @@ interface InfiniteTableProps<T> {
     showHoverRows?: boolean;
     sortable?: boolean;
     keyboardNavigation?: InfiniteTablePropKeyboardNavigation;
+    keyboardSelection?: InfiniteTablePropKeyboardSelection;
     defaultActiveRowIndex?: number | null;
     activeRowIndex?: number | null;
     onActiveRowIndexChange?: (activeRowIndex: number) => void;
@@ -1789,6 +1912,7 @@ interface InfiniteTableProps<T> {
     columnDefaultWidth?: number;
     columnMinWidth?: number;
     columnMaxWidth?: number;
+    hideColumnWhenGrouped?: boolean;
     resizableColumns?: boolean;
     virtualizeColumns?: InfiniteTablePropVirtualizeColumns<T>;
     virtualizeRows?: boolean;
@@ -1806,13 +1930,14 @@ interface InfiniteTableProps<T> {
     onColumnOrderChange?: (columnOrder: InfiniteTablePropColumnOrderNormalized) => void;
     onRowHeightChange?: (rowHeight: number) => void;
     filterEditors?: InfiniteTablePropFilterEditors<T>;
-    onReady?: (api: InfiniteTableImperativeApi<T>) => void;
+    onReady?: (api: InfiniteTableApi<T>) => void;
     rowProps?: React$1.HTMLProps<HTMLDivElement> | ((rowArgs: InfiniteTableRowStyleFnParams<T>) => React$1.HTMLProps<HTMLDivElement>);
     licenseKey?: string;
     scrollTopKey?: string | number;
     autoSizeColumnsKey?: InfiniteTablePropAutoSizeColumnsKey;
 }
 declare type InfiniteTablePropKeyboardNavigation = 'cell' | 'row' | false;
+declare type InfiniteTablePropKeyboardSelection = boolean;
 declare type InfiniteTablePropHeaderOptions = {
     alwaysReserveSpaceForSortIcon: boolean;
 };
@@ -1832,12 +1957,6 @@ declare function debounce(fn: Function, { wait }: {
     wait: number;
 }): (...args: any[]) => void;
 
-declare const defaultFilterTypes: Record<string, DataSourceFilterType<any>>;
-
-declare function useDataSource<T>(): DataSourceState<T>;
-
-declare function DataSource<T>(props: DataSourceProps<T>): JSX.Element;
-
 declare type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT> = {
     [propName in keyof TYPE_PROPS & keyof TYPE_RESULT]: 1 | ((value: TYPE_PROPS[propName]) => TYPE_RESULT[propName]);
 };
@@ -1900,4 +2019,4 @@ declare const components: {
     LoadMask: (props: LoadMaskProps) => 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, DataSourcePropCellSelection, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropPivotBy, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnsMap, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableFilterEditorProps, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTableImperativeApi, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropFilterEditors, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, NumberFilterEditor, RowSelectionState, Scrollbars, StringFilterEditor, components, debounce, defaultFilterEditors, defaultFilterTypes, defaultFilterTypes as filterTypes, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };
+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, DataSourcePropCellSelection, DataSourcePropFilterFunction, DataSourcePropFilterTypes, DataSourcePropFilterValue, DataSourcePropGroupBy, DataSourcePropGroupRowsStateObject, DataSourcePropIsRowSelected, DataSourcePropLivePaginationCursor, DataSourcePropMultiRowSelectionChangeParamType, DataSourcePropOnCellSelectionChange, DataSourcePropOnRowSelectionChange, DataSourcePropOnRowSelectionChange_MultiRow, DataSourcePropOnRowSelectionChange_SingleRow, DataSourcePropPivotBy, DataSourcePropRowSelection, DataSourcePropRowSelection_MultiRow, DataSourcePropRowSelection_SingleRow, DataSourcePropSelectionMode, DataSourcePropSortInfo, DataSourcePropSortTypes, DataSourceProps, DataSourceReducer, DataSourceRemoteData, DataSourceSetupState, DataSourceSingleSortInfo, DataSourceSortInfo, DataSourceState, GroupRowsState, InfiniteTable, InfiniteTableAction, InfiniteTableActionType, InfiniteTableApi, InfiniteTableClassName, InfiniteTableColumn, InfiniteTableColumnAggregator, InfiniteTableColumnComparer, InfiniteTableColumnGroup, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableColumnRowspanParam, InfiniteTableColumnSizingOptions, InfiniteTableColumnsMap, InfiniteTableComponent, InfiniteTableComputedColumn, InfiniteTableComputedValues, InfiniteTableContextValue, InfiniteTableFilterEditorProps, InfiniteTableGroupColumnBase, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePivotColumn, InfiniteTablePropAutoSizeColumnsKey, InfiniteTablePropColumnGroups, InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnVisibility, InfiniteTablePropColumns, InfiniteTablePropComponents, InfiniteTablePropFilterEditors, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropHeaderOptions, InfiniteTablePropKeyboardNavigation, InfiniteTablePropRowClassName, InfiniteTablePropRowStyle, InfiniteTableProps, InfiniteTableRowClassNameFn, InfiniteTableRowInfo, InfiniteTableRowStyleFn, InfiniteTableState, LazyGroupDataDeepMap, LazyGroupDataItem, LazyRowInfoGroup, NumberFilterEditor, RowSelectionState, Scrollbars, StringFilterEditor, components, debounce, defaultFilterEditors, defaultFilterTypes, defaultFilterTypes as filterTypes, flatten, getComponentStateRoot, group, interceptMap, multisort, useComponentState, useDataSource, useEffectWithChanges, useInfiniteColumnCell, useInfiniteHeaderCell };