@jetbrains/ring-ui 4.1.4 → 5.0.0-beta.1

package/dist/table/row.js

@@ -6,7 +6,7 @@ import chevronRightIcon from '@jetbrains/icons/chevron-right';
 import chevronDownIcon from '@jetbrains/icons/chevron-down';
 import dragIcon from '@jetbrains/icons/drag';
 import Checkbox from '../checkbox/checkbox.js';
-import Button from '../button/button.js';
+import ThemedButton from '../button/button.js';
 import Tooltip from '../tooltip/tooltip.js';
 import joinDataTestAttributes from '../global/data-tests.js';
 import getUID from '../global/get-uid.js';
@@ -48,7 +48,7 @@ const DragHandle = _ref => {
   const classes = classNames(modules_1db4bbca.dragHandle, {
     [modules_1db4bbca.visibleDragHandle]: alwaysShowDragHandle
   });
-  return /*#__PURE__*/React.createElement(Button, {
+  return /*#__PURE__*/React.createElement(ThemedButton, {
     "data-movable-handle": true,
     title: "Drag",
     className: classes,
@@ -65,12 +65,12 @@ class Row extends PureComponent {
 
     _defineProperty(this, "id", getUID('table-row-'));
 
-    _defineProperty(this, "onMouseEnter", () => {
+    _defineProperty(this, "onMouseEnter", e => {
       const {
         item,
         onHover
       } = this.props;
-      onHover(item);
+      onHover(item, e);
     });
 
     _defineProperty(this, "onClick", e => {
@@ -99,6 +99,8 @@ class Row extends PureComponent {
       this.props.onDoubleClick(item);
     });
 
+    _defineProperty(this, "row", void 0);
+
     _defineProperty(this, "rowRef", el => {
       this.row = el;
     });
@@ -133,6 +135,7 @@ class Row extends PureComponent {
       onCollapse,
       onExpand,
       showDisabledSelection,
+      onSelect,
       checkboxTooltip,
       innerRef,
       focused,
@@ -173,18 +176,18 @@ class Row extends PureComponent {
       checked: selected,
       onFocus: this.onCheckboxFocus,
       onChange: this.onCheckboxChange,
-      tabIndex: "-1"
+      tabIndex: -1
     })), !selectable && showDisabledSelection && /*#__PURE__*/React.createElement(Tooltip, {
       title: checkboxTooltip
     }, /*#__PURE__*/React.createElement(Checkbox, {
       "aria-labelledby": this.id,
       checked: selected,
       disabled: true
-    })), collapsible && collapsed && /*#__PURE__*/React.createElement(Button, {
+    })), collapsible && collapsed && /*#__PURE__*/React.createElement(ThemedButton, {
       className: modules_1db4bbca.rowCollapseExpandButton,
       icon: chevronRightIcon,
       onClick: () => onExpand(item)
-    }), collapsible && !collapsed && /*#__PURE__*/React.createElement(Button, {
+    }), collapsible && !collapsed && /*#__PURE__*/React.createElement(ThemedButton, {
       className: modules_1db4bbca.rowCollapseExpandButton,
       icon: chevronDownIcon,
       onClick: () => onCollapse(item)
@@ -209,7 +212,7 @@ class Row extends PureComponent {
       id: this.id,
       ref: composeRefs(this.rowRef, innerRef),
       className: classes,
-      tabIndex: "0",
+      tabIndex: 0,
       "data-test": joinDataTestAttributes('ring-table-row', dataTest)
     }, testAttrs, restProps, {
       onMouseMove: this.onMouseEnter,
@@ -220,7 +223,25 @@ class Row extends PureComponent {
 
 }
 
-_defineProperty(Row, "propTypes", {
+_defineProperty(Row, "defaultProps", {
+  selectable: true,
+  showFocus: false,
+  draggable: false,
+  alwaysShowDragHandle: false,
+  selected: false,
+  onHover: () => {},
+  onSelect: () => {},
+  onDoubleClick: () => {},
+  onClick: () => {},
+  level: 0,
+  collapsible: false,
+  parentCollapsible: false,
+  collapsed: false,
+  onCollapse: () => {},
+  onExpand: () => {}
+});
+
+Row.propTypes = {
   className: PropTypes.string,
   item: PropTypes.object.isRequired,
   columns: PropTypes.array.isRequired,
@@ -247,25 +268,6 @@ _defineProperty(Row, "propTypes", {
   autofocus: PropTypes.bool,
   onFocusReset: PropTypes.func,
   'data-test': PropTypes.string
-});
-
-_defineProperty(Row, "defaultProps", {
-  selectable: true,
-  showFocus: false,
-  draggable: false,
-  alwaysShowDragHandle: false,
-  selected: false,
-  onHover: () => {},
-  onSelect: () => {},
-  onDoubleClick: () => {},
-  onClick: () => {},
-  onFocusRestore: () => {},
-  level: 0,
-  collapsible: false,
-  parentCollapsible: false,
-  collapsed: false,
-  onCollapse: () => {},
-  onExpand: () => {}
-});
+};
 
 export { Row as default };

package/dist/table/selection-adapter.d.ts

@@ -0,0 +1,5 @@
+import Selection, { SelectionItem } from './selection';
+export default function selectionAdapter(getSelection: () => Selection<SelectionItem>): {
+    readonly size: number;
+    readonly items: SelectionItem[];
+};

package/dist/table/selection-shortcuts-hoc.d.ts

@@ -0,0 +1,17 @@
+import { ComponentType } from 'react';
+import { ShortcutsMap } from '../shortcuts/core';
+import Selection, { SelectionItem } from './selection';
+export interface SelectionShortcutsOuterProps<T extends SelectionItem> {
+    selection: Selection<T>;
+    selectable?: boolean | undefined;
+    onSelect?: ((selection: Selection<T>) => void) | undefined;
+    shortcuts?: ShortcutsMap | undefined;
+}
+export interface SelectionShortcutsAddProps<T extends SelectionItem> {
+    selection: Selection<T>;
+    selectable: boolean;
+    onSelect: (selection: Selection<T>) => void;
+    shortcutsMap: ShortcutsMap;
+}
+export declare type SelectionShortcutsProps<T extends SelectionItem, P> = Omit<P, keyof SelectionShortcutsAddProps<T>> & SelectionShortcutsOuterProps<T>;
+export default function selectionShortcutsHOC<T extends SelectionItem, P extends SelectionShortcutsAddProps<T>>(ComposedComponent: ComponentType<P>): ComponentType<SelectionShortcutsProps<T, P>>;

package/dist/table/selection-shortcuts-hoc.js

@@ -3,10 +3,27 @@ import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import Selection from './selection.js';
 
-function selectionShortcutsHOC(ComposedComponent) {
-  var _class, _temp;
+function extractPropTypes(_ref) {
+  let {
+    propTypes
+  } = _ref;
+
+  if (propTypes == null) {
+    return propTypes;
+  }
+
+  const {
+    selection,
+    selectable,
+    onSelect,
+    shortcutsMap,
+    ...restPropTypes
+  } = propTypes;
+  return restPropTypes;
+}
 
-  return _temp = _class = class SelectionShortcuts extends PureComponent {
+function selectionShortcutsHOC(ComposedComponent) {
+  class SelectionShortcuts extends PureComponent {
     constructor() {
       super(...arguments);
 
@@ -18,7 +35,7 @@ function selectionShortcutsHOC(ComposedComponent) {
         const newSelection = selection.moveUp();
 
         if (newSelection) {
-          onSelect(newSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newSelection);
         }
 
         return false;
@@ -32,12 +49,14 @@ function selectionShortcutsHOC(ComposedComponent) {
         const newSelection = selection.moveDown();
 
         if (newSelection) {
-          onSelect(newSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newSelection);
         }
 
         return false;
       });
 
+      _defineProperty(this, "shiftSelectionMode", void 0);
+
       _defineProperty(this, "onShiftKeyDown", () => {
         const {
           selection
@@ -74,9 +93,9 @@ function selectionShortcutsHOC(ComposedComponent) {
         const newMovedSelection = newSelection.moveUp();
 
         if (newMovedSelection) {
-          onSelect(newMovedSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newMovedSelection);
         } else {
-          onSelect(newSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newSelection);
         }
       });
 
@@ -96,9 +115,9 @@ function selectionShortcutsHOC(ComposedComponent) {
         const newMovedSelection = newSelection.moveDown();
 
         if (newMovedSelection) {
-          onSelect(newMovedSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newMovedSelection);
         } else {
-          onSelect(newSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newSelection);
         }
       });
 
@@ -110,7 +129,7 @@ function selectionShortcutsHOC(ComposedComponent) {
         const newSelection = selection.moveStart();
 
         if (newSelection) {
-          onSelect(newSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newSelection);
         }
 
         return false;
@@ -124,7 +143,7 @@ function selectionShortcutsHOC(ComposedComponent) {
         const newSelection = selection.moveEnd();
 
         if (newSelection) {
-          onSelect(newSelection);
+          onSelect === null || onSelect === void 0 ? void 0 : onSelect(newSelection);
         }
 
         return false;
@@ -141,7 +160,7 @@ function selectionShortcutsHOC(ComposedComponent) {
           return true;
         }
 
-        onSelect(selection.toggleSelection());
+        onSelect === null || onSelect === void 0 ? void 0 : onSelect(selection.toggleSelection());
         return false;
       });
 
@@ -150,7 +169,7 @@ function selectionShortcutsHOC(ComposedComponent) {
           selection,
           onSelect
         } = this.props;
-        onSelect(selection.reset()); //this.restoreFocusWithoutScroll();
+        onSelect === null || onSelect === void 0 ? void 0 : onSelect(selection.reset()); //this.restoreFocusWithoutScroll();
       });
 
       _defineProperty(this, "onCmdAPress", () => {
@@ -164,7 +183,7 @@ function selectionShortcutsHOC(ComposedComponent) {
           return true;
         }
 
-        onSelect(selection.selectAll());
+        onSelect === null || onSelect === void 0 ? void 0 : onSelect(selection.selectAll());
         return false;
       });
 
@@ -187,9 +206,11 @@ function selectionShortcutsHOC(ComposedComponent) {
       const {
         selection,
         selectable,
-        onSelect
+        onSelect,
+        shortcuts,
+        ...restProps
       } = this.props;
-      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, this.props, {
+      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, restProps, {
         selection: selection,
         selectable: selectable,
         onSelect: onSelect,
@@ -199,16 +220,20 @@ function selectionShortcutsHOC(ComposedComponent) {
       }));
     }
 
-  }, _defineProperty(_class, "propTypes", { ...ComposedComponent.propTypes,
+  }
+
+  SelectionShortcuts.propTypes = { ...extractPropTypes(ComposedComponent),
     selection: PropTypes.instanceOf(Selection).isRequired,
     selectable: PropTypes.bool,
     onSelect: PropTypes.func,
     shortcuts: PropTypes.object
-  }), _defineProperty(_class, "defaultProps", { ...ComposedComponent.defaultProps,
+  };
+  SelectionShortcuts.defaultProps = { ...ComposedComponent.defaultProps,
     selectable: true,
     onSelect: () => {},
     shortcuts: {}
-  }), _temp;
+  };
+  return SelectionShortcuts;
 }
 
 export { selectionShortcutsHOC as default };

package/dist/table/selection.d.ts

@@ -0,0 +1,47 @@
+export interface SelectionItem {
+    id: string | number;
+    [key: string]: unknown;
+}
+export interface TableSelectionConfig<T extends SelectionItem> {
+    data?: readonly T[] | undefined;
+    selected?: Set<T> | undefined;
+    focused?: T | null | undefined;
+    getKey?: ((item: T) => string | number) | undefined;
+    isItemSelectable?: ((item: T) => boolean | undefined) | undefined;
+    getChildren?: ((item: T) => readonly T[]) | undefined;
+}
+export interface CloneWithConfig<T> {
+    data?: readonly T[] | null | undefined;
+    selected?: Set<T> | readonly T[] | null | undefined;
+    focused?: T | null | undefined;
+}
+export default class Selection<T extends SelectionItem> {
+    private _rawData;
+    protected _getChildren: ((item: T) => readonly T[]);
+    protected _data: Set<T>;
+    protected _selected: Set<T>;
+    protected _focused: T | null;
+    private _getKey;
+    protected _isItemSelectable: (item: T) => boolean | undefined;
+    constructor({ data, selected, focused, getKey, getChildren, isItemSelectable }?: TableSelectionConfig<T>);
+    protected _buildData(data: readonly T[] | null | undefined): Set<T>;
+    protected _buildSelected(data: Set<T>, selected: Set<T>): Set<T>;
+    cloneWith({ data, selected, focused }: CloneWithConfig<T>): Selection<T>;
+    focus(value: T | null | undefined): Selection<T>;
+    moveUp(): Selection<T> | undefined;
+    moveDown(): Selection<T> | undefined;
+    moveStart(): Selection<T> | undefined;
+    moveEnd(): Selection<T> | undefined;
+    select(value?: T | null): Selection<T>;
+    deselect(value?: T | null): Selection<T>;
+    toggleSelection(value?: T | null): Selection<T>;
+    selectAll(): Selection<T>;
+    resetFocus(): Selection<T>;
+    resetSelection(): Selection<T>;
+    reset(): Selection<T>;
+    isFocused(value: T | null): boolean;
+    isSelected(value: T | null): boolean;
+    getFocused(): T | null;
+    getSelected(): Set<T>;
+    getActive(): Set<T>;
+}

package/dist/table/selection.js

@@ -1,3 +1,5 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+
 class Selection {
   constructor() {
     let {
@@ -8,6 +10,21 @@ class Selection {
       getChildren = () => [],
       isItemSelectable = () => true
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _defineProperty(this, "_rawData", void 0);
+
+    _defineProperty(this, "_getChildren", void 0);
+
+    _defineProperty(this, "_data", void 0);
+
+    _defineProperty(this, "_selected", void 0);
+
+    _defineProperty(this, "_focused", void 0);
+
+    _defineProperty(this, "_getKey", void 0);
+
+    _defineProperty(this, "_isItemSelectable", void 0);
+
     this._rawData = data;
     this._getChildren = getChildren;
     this._data = this._buildData(data);
@@ -195,7 +212,7 @@ class Selection {
   }
 
   isSelected(value) {
-    return this._selected.has(value);
+    return value != null && this._selected.has(value);
   }
 
   getFocused() {

package/dist/table/smart-table.d.ts

@@ -0,0 +1,60 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import { TableAttrs } from './table';
+import Selection, { SelectionItem } from './selection';
+export interface SmartTableProps<T extends SelectionItem> extends Omit<TableAttrs<T>, 'selection' | 'onSelect'> {
+    onSelectionChange: (selection: Selection<T>) => void;
+}
+declare class SmartTable<T extends SelectionItem> extends PureComponent<SmartTableProps<T>> {
+    static propTypes: {
+        className?: React.Validator<string | null | undefined> | undefined;
+        onFocus?: React.Validator<(() => void) | null | undefined> | undefined;
+        onBlur?: React.Validator<(() => void) | null | undefined> | undefined;
+        caption?: React.Validator<string | null | undefined> | undefined;
+        data?: React.Validator<readonly SelectionItem[]> | undefined;
+        loading?: React.Validator<boolean | null | undefined> | undefined;
+        draggable?: React.Validator<boolean | null | undefined> | undefined;
+        columns?: React.Validator<readonly import("./header-cell").Column<SelectionItem>[]> | undefined;
+        focused?: React.Validator<boolean | null | undefined> | undefined;
+        isItemSelectable: PropTypes.Requireable<(...args: any[]) => any> | React.Validator<((item: SelectionItem) => boolean) | null | undefined>;
+        innerRef?: React.Validator<React.Ref<HTMLTableRowElement> | undefined> | undefined;
+        autofocus?: React.Validator<boolean | null | undefined> | undefined;
+        disabledHover?: React.Validator<boolean> | undefined;
+        remoteSelection?: React.Validator<boolean | null | undefined> | undefined;
+        onSort?: React.Validator<((params: import("./header-cell").SortParams) => void) | null | undefined> | undefined;
+        sortKey?: React.Validator<string | null | undefined> | undefined;
+        sortOrder?: React.Validator<boolean | null | undefined> | undefined;
+        alwaysShowDragHandle?: React.Validator<boolean | null | undefined> | undefined;
+        onReorder?: React.Validator<((params: import("./table").ReorderParams<SelectionItem>) => void) | null | undefined> | undefined;
+        getItemKey?: React.Validator<((item: SelectionItem) => string | number) | null | undefined> | undefined;
+        stickyHeader?: React.Validator<boolean | null | undefined> | undefined;
+        getItemLevel?: React.Validator<((item: SelectionItem) => number) | null | undefined> | undefined;
+        getItemClassName?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
+        getItemDataTest?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
+        isItemCollapsible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        isParentCollapsible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        isItemCollapsed?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        onItemCollapse?: React.Validator<((item: SelectionItem) => void) | null | undefined> | undefined;
+        onItemExpand?: React.Validator<((item: SelectionItem) => void) | null | undefined> | undefined;
+        onItemDoubleClick?: React.Validator<((item: SelectionItem) => void) | null | undefined> | undefined;
+        onItemClick?: React.Validator<((item: SelectionItem, e: React.MouseEvent<HTMLTableRowElement, MouseEvent>) => void) | null | undefined> | undefined;
+        isDisabledSelectionVisible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        getCheckboxTooltip?: React.Validator<((item: SelectionItem) => string | undefined) | null | undefined> | undefined;
+        loaderClassName?: React.Validator<string | null | undefined> | undefined;
+        stickyHeaderOffset?: React.Validator<string | null | undefined> | undefined;
+        renderEmpty?: React.Validator<(() => React.ReactNode) | null | undefined> | undefined;
+        selectable?: React.Validator<boolean | null | undefined> | undefined;
+        shortcuts?: React.Validator<import("../shortcuts/core").ShortcutsMap | null | undefined> | undefined;
+        onSelectionChange: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        onSelectionChange: () => void;
+    };
+    state: {
+        selection: Selection<T>;
+    };
+    UNSAFE_componentWillReceiveProps(nextProps: SmartTableProps<T>): void;
+    onSelect: (selection: Selection<T>) => void;
+    render(): JSX.Element;
+}
+export default SmartTable;

package/dist/table/smart-table.js

@@ -1,11 +1,12 @@
 import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
-import Table from './table.js';
+import TableContainer from './table.js';
 import Selection from './selection.js';
 import 'classnames';
 import 'react-movable';
 import '../global/focus-sensor-hoc.js';
+import '../global/prop-types.js';
 import '../global/composeRefs.js';
 import '../global/get-uid.js';
 import '../shortcuts/shortcuts.js';
@@ -55,11 +56,12 @@ import '../popup/popup.consts.js';
 import '../popup/popup.target.js';
 import './cell.js';
 
+var _Table$propTypes;
 const {
   selection: __selection__,
   onSelect: __onSelect__,
   ...restPropTypes
-} = Table.propTypes;
+} = (_Table$propTypes = TableContainer.propTypes) !== null && _Table$propTypes !== void 0 ? _Table$propTypes : {};
 
 class SmartTable extends PureComponent {
   constructor() {
@@ -98,7 +100,7 @@ class SmartTable extends PureComponent {
   }
 
   render() {
-    return /*#__PURE__*/React.createElement(Table, _extends({}, this.props, {
+    return /*#__PURE__*/React.createElement(TableContainer, _extends({}, this.props, {
       selection: this.state.selection,
       onSelect: this.onSelect
     }));

package/dist/table/table.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @name Table
+ */
+import React, { Component, PureComponent, ReactNode, SyntheticEvent } from 'react';
+import { OnChangeMeta } from 'react-movable/lib/types';
+import { FocusSensorAddProps, FocusSensorProps } from '../global/focus-sensor-hoc';
+import { SelectionItem } from './selection';
+import { SelectionShortcutsAddProps, SelectionShortcutsProps } from './selection-shortcuts-hoc';
+import { DisableHoverAddProps, DisableHoverProps } from './disable-hover-hoc';
+import { Column, SortParams } from './header-cell';
+export interface ReorderParams<T> {
+    data: T[];
+    oldIndex: number;
+    newIndex: number;
+}
+export interface TableProps<T extends SelectionItem> extends FocusSensorAddProps<HTMLTableRowElement>, SelectionShortcutsAddProps<T>, DisableHoverAddProps {
+    data: readonly T[];
+    columns: readonly Column<T>[];
+    isItemSelectable: (item: T) => boolean;
+    loading: boolean;
+    onSort: (params: SortParams) => void;
+    onReorder: (params: ReorderParams<T>) => void;
+    getItemKey: (item: T) => string | number;
+    sortKey: string;
+    sortOrder: boolean;
+    draggable: boolean;
+    alwaysShowDragHandle: boolean;
+    stickyHeader: boolean;
+    getItemLevel: (item: T) => number;
+    getItemClassName: (item: T) => string | null | undefined;
+    getItemDataTest: (item: T) => string | null | undefined;
+    isItemCollapsible: (item: T) => boolean;
+    isParentCollapsible: (item: T) => boolean;
+    isItemCollapsed: (item: T) => boolean;
+    onItemCollapse: (item: T) => void;
+    onItemExpand: (item: T) => void;
+    onItemDoubleClick: (item: T) => void;
+    onItemClick: (item: T, e: React.MouseEvent<HTMLTableRowElement>) => void;
+    remoteSelection: boolean;
+    isDisabledSelectionVisible: (item: T) => boolean;
+    getCheckboxTooltip: (item: T) => string | undefined;
+    className?: string | null | undefined;
+    loaderClassName?: string | undefined;
+    caption?: string | null | undefined;
+    stickyHeaderOffset?: string | undefined;
+    renderEmpty?: (() => ReactNode) | null | undefined;
+}
+/**
+ * Interactive table with selection and keyboard navigation support.
+ */
+export declare class Table<T extends SelectionItem> extends PureComponent<TableProps<T>> {
+    static defaultProps: {
+        isItemSelectable: () => boolean;
+        loading: boolean;
+        onSort: () => void;
+        onReorder: () => void;
+        getItemKey: (item: SelectionItem) => string | number;
+        sortKey: string;
+        sortOrder: boolean;
+        draggable: boolean;
+        alwaysShowDragHandle: boolean;
+        stickyHeader: boolean;
+        getItemLevel: () => number;
+        getItemClassName: () => null;
+        getItemDataTest: () => null;
+        isItemCollapsible: () => boolean;
+        isParentCollapsible: () => boolean;
+        isItemCollapsed: () => boolean;
+        onItemCollapse: () => void;
+        onItemExpand: () => void;
+        onItemDoubleClick: () => void;
+        onItemClick: () => void;
+        remoteSelection: boolean;
+        isDisabledSelectionVisible: () => boolean;
+        getCheckboxTooltip: () => undefined;
+    };
+    state: {
+        shortcutsScope: string;
+        userSelectNone: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate({ data, selection, onSelect, selectable, remoteSelection }: TableProps<T>): void;
+    componentWillUnmount(): void;
+    onMouseDown: (e: React.MouseEvent) => void;
+    onMouseUp: () => void;
+    onRowFocus: (row: T) => void;
+    onRowSelect: (row: T, selected: boolean) => void;
+    onSortEnd: ({ oldIndex, newIndex }: OnChangeMeta) => void;
+    onCheckboxChange: (e: SyntheticEvent<HTMLInputElement>) => void;
+    restoreFocusWithoutScroll: () => void;
+    render(): JSX.Element;
+}
+export declare type TableAttrs<T extends SelectionItem> = DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>;
+export default class TableContainer<T extends SelectionItem> extends Component<TableAttrs<T>> {
+    static propTypes: React.WeakValidationMap<SelectionShortcutsProps<SelectionItem, FocusSensorProps<TableProps<SelectionItem>, HTMLTableRowElement, typeof Table>>> | undefined;
+    Table: {
+        new (props: DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>): {
+            state: {
+                disabledHover: boolean;
+            };
+            componentDidMount(): void;
+            componentWillUnmount(): void;
+            onMouseMove: () => void;
+            onKeyDown: (e: KeyboardEvent) => void;
+            render(): JSX.Element;
+            context: any;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        new (props: DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>, context: any): {
+            state: {
+                disabledHover: boolean;
+            };
+            componentDidMount(): void;
+            componentWillUnmount(): void;
+            onMouseMove: () => void;
+            onKeyDown: (e: KeyboardEvent) => void;
+            render(): JSX.Element;
+            context: any;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        propTypes: React.WeakValidationMap<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | undefined;
+        defaultProps: Partial<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | undefined;
+        contextType?: React.Context<any> | undefined;
+    };
+    render(): JSX.Element;
+}