@jetbrains/ring-ui-built 6.0.1

package/components/confirm-service/confirm-service.js

@@ -0,0 +1,141 @@
+import { e as _objectWithoutProperties, g as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.symbol.js';
+import 'core-js/modules/es.symbol.description.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import Confirm from '../confirm/confirm.js';
+import { ControlsHeightContext, getGlobalControlsHeight } from '../global/controls-height.js';
+import 'core-js/modules/es.array.concat.js';
+import 'prop-types';
+import '../dialog/dialog.js';
+import 'react-dom';
+import 'classnames';
+import '@jetbrains/icons/close';
+import '../island/island.js';
+import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
+import '../island/adaptive-island-hoc.js';
+import '../global/linear-function.js';
+import '../_helpers/island.js';
+import '../island/header.js';
+import '../island/content.js';
+import 'element-resize-detector';
+import '../global/schedule-raf.js';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../shortcuts/shortcuts.js';
+import 'core-js/modules/es.array.map.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import 'core-js/modules/es.array.filter.js';
+import '../global/dom.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.weak-map.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+import '../popup/popup.target.js';
+import '../_helpers/dialog__body-scroll-preventer.js';
+import 'scrollbar-width';
+import '../panel/panel.js';
+
+var _excluded = ["buttonsHeight"];
+var containerElement = document.createElement('div');
+var reactRoot = createRoot(containerElement);
+/**
+ * Renders Confirm into virtual node to skip maintaining container
+ */
+function renderConfirm(props) {
+  var _props$buttonsHeight = props.buttonsHeight,
+    buttonsHeight = _props$buttonsHeight === void 0 ? getGlobalControlsHeight() : _props$buttonsHeight,
+    restProps = _objectWithoutProperties(props, _excluded);
+  reactRoot.render( /*#__PURE__*/React.createElement(ControlsHeightContext.Provider, {
+    value: buttonsHeight
+  }, /*#__PURE__*/React.createElement(Confirm, restProps)));
+}
+function confirm(_ref) {
+  var text = _ref.text,
+    description = _ref.description,
+    _ref$confirmLabel = _ref.confirmLabel,
+    confirmLabel = _ref$confirmLabel === void 0 ? 'OK' : _ref$confirmLabel,
+    _ref$rejectLabel = _ref.rejectLabel,
+    rejectLabel = _ref$rejectLabel === void 0 ? 'Cancel' : _ref$rejectLabel,
+    cancelIsDefault = _ref.cancelIsDefault,
+    onBeforeConfirm = _ref.onBeforeConfirm,
+    buttonsHeight = _ref.buttonsHeight;
+  return new Promise(function (resolve, reject) {
+    var props = {
+      text,
+      description,
+      confirmLabel,
+      rejectLabel,
+      cancelIsDefault,
+      buttonsHeight,
+      show: true,
+      onConfirm: function onConfirm() {
+        if (onBeforeConfirm) {
+          renderConfirm(_objectSpread2(_objectSpread2({}, props), {}, {
+            inProgress: true
+          }));
+          return Promise.resolve(onBeforeConfirm()).then(function () {
+            renderConfirm(_objectSpread2(_objectSpread2({}, props), {}, {
+              show: false
+            }));
+            resolve();
+          }).catch(function (err) {
+            renderConfirm(_objectSpread2(_objectSpread2({}, props), {}, {
+              show: false
+            }));
+            reject(err);
+          });
+        }
+        renderConfirm(_objectSpread2(_objectSpread2({}, props), {}, {
+          show: false
+        }));
+        return resolve();
+      },
+      onReject: function onReject() {
+        renderConfirm(_objectSpread2(_objectSpread2({}, props), {}, {
+          show: false
+        }));
+        reject(new Error('Confirm(@jetbrains/ring-ui): null exception'));
+      }
+    };
+    renderConfirm(props);
+  });
+}
+function hideConfirm() {
+  renderConfirm({
+    text: '',
+    show: false
+  });
+}
+
+export { confirm as default, hideConfirm, reactRoot };

package/components/content-layout/content-layout.d.ts

@@ -0,0 +1,26 @@
+import React, { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface ContentLayoutProps extends HTMLAttributes<HTMLElement> {
+    responsive: boolean;
+    contentClassName?: string | null | undefined;
+}
+/**
+ * @name Content Layout
+ */
+export default class ContentLayout extends Component<ContentLayoutProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        contentClassName: PropTypes.Requireable<string>;
+        responsive: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        responsive: boolean;
+    };
+    state: {
+        contentNode: null;
+    };
+    saveContentNode: (contentNode: HTMLElement | null) => void;
+    render(): React.JSX.Element;
+}
+export { default as Sidebar } from './sidebar';

package/components/content-layout/content-layout.js

@@ -0,0 +1,79 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.array.filter.js';
+import React, { cloneElement, Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { m as modules_b8a9dd4f, S as Sidebar } from '../_helpers/sidebar.js';
+import 'react-waypoint';
+
+var _excluded = ["children", "className", "contentClassName", "responsive"];
+/**
+ * @name Content Layout
+ */
+var ContentLayout = /*#__PURE__*/function (_Component) {
+  _inherits(ContentLayout, _Component);
+  var _super = _createSuper(ContentLayout);
+  function ContentLayout() {
+    var _this;
+    _classCallCheck(this, ContentLayout);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      contentNode: null
+    });
+    _defineProperty(_assertThisInitialized(_this), "saveContentNode", function (contentNode) {
+      _this.setState({
+        contentNode
+      });
+    });
+    return _this;
+  }
+  _createClass(ContentLayout, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        contentClassName = _this$props.contentClassName,
+        responsive = _this$props.responsive,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_b8a9dd4f.contentLayout, className, {
+        [modules_b8a9dd4f.contentLayoutResponsive]: responsive
+      });
+      var contentClasses = classNames(modules_b8a9dd4f.contentLayoutContent, contentClassName);
+      var childrenArray = React.Children.toArray(children);
+      var sidebarChild = childrenArray.filter(function (child) {
+        return child != null && typeof child === 'object' && 'type' in child && child.type === Sidebar;
+      })[0];
+      var sidebar = sidebarChild && /*#__PURE__*/cloneElement(sidebarChild, {
+        contentNode: this.state.contentNode
+      });
+      var contentChildren = childrenArray.filter(function (child) {
+        return child !== sidebarChild;
+      });
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        className: classes
+      }), sidebar, /*#__PURE__*/React.createElement("main", {
+        className: contentClasses,
+        ref: this.saveContentNode
+      }, contentChildren));
+    }
+  }]);
+  return ContentLayout;
+}(Component);
+_defineProperty(ContentLayout, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  contentClassName: PropTypes.string,
+  responsive: PropTypes.bool
+});
+_defineProperty(ContentLayout, "defaultProps", {
+  responsive: true
+});
+
+export { Sidebar, ContentLayout as default };

package/components/content-layout/sidebar.d.ts

@@ -0,0 +1,31 @@
+import React, { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+import { Waypoint } from 'react-waypoint';
+export interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    right?: boolean | null | undefined;
+    containerClassName?: string | null | undefined;
+    fixedClassName?: string | null | undefined;
+    contentNode?: HTMLElement | null | undefined;
+}
+export default class Sidebar extends Component<SidebarProps> {
+    static propTypes: {
+        right: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        containerClassName: PropTypes.Requireable<string>;
+        fixedClassName: PropTypes.Requireable<string>;
+        contentNode: PropTypes.Requireable<object>;
+    };
+    state: {
+        topIsOutside: boolean;
+        bottomIsOutside: boolean;
+        sidebarVisibleHeight: undefined;
+    };
+    sidebarNode?: HTMLElement | null;
+    handleTopWaypoint: ({ currentPosition }: Waypoint.CallbackArgs) => void;
+    handleBottomWaypoint: ({ currentPosition, waypointTop }: Waypoint.CallbackArgs) => void;
+    shouldUseFixation(): boolean;
+    shouldFixateBottom(): boolean;
+    sidebarRef: (node: HTMLElement | null) => void;
+    render(): React.JSX.Element;
+}

package/components/content-layout/sidebar.js

@@ -0,0 +1,7 @@
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'react';
+import 'prop-types';
+import 'classnames';
+import 'react-waypoint';
+export { S as default } from '../_helpers/sidebar.js';

package/components/contenteditable/contenteditable.d.ts

@@ -0,0 +1,47 @@
+import React, { Component, HTMLAttributes, Ref } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name ContentEditable
+ */
+declare function noop(): void;
+export interface ContentEditableBaseProps extends HTMLAttributes<HTMLElement> {
+    disabled: boolean;
+    onComponentUpdate: ((prevProps: ContentEditableBaseProps) => void);
+    inputRef?: Ref<HTMLDivElement> | null | undefined;
+    __html: string;
+}
+declare class ContentEditableBase extends Component<ContentEditableBaseProps> {
+    static propTypes: {
+        __html: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        disabled: boolean;
+        tabIndex: number;
+        onInput: typeof noop;
+        onComponentUpdate: typeof noop;
+    };
+    shouldComponentUpdate(nextProps: ContentEditableBaseProps): boolean;
+    componentDidUpdate(prevProps: ContentEditableBaseProps): void;
+    render(): React.JSX.Element;
+}
+type ContentEditableBaseAttrs = JSX.LibraryManagedAttributes<typeof ContentEditableBase, ContentEditableBaseProps>;
+export type ContentEditableProps = Omit<ContentEditableBaseAttrs, '__html'>;
+declare const ContentEditable: {
+    ({ children, ...props }: ContentEditableProps): React.JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+};
+export default ContentEditable;

package/components/contenteditable/contenteditable.js

@@ -0,0 +1,84 @@
+import { _ as _defineProperty, g as _objectSpread2, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { renderToStaticMarkup } from 'react-dom/server';
+
+var _excluded = ["__html", "onComponentUpdate", "disabled", "tabIndex", "inputRef"],
+  _excluded2 = ["children"];
+/**
+ * @name ContentEditable
+ */
+function noop() {}
+var commonPropTypes = {
+  disabled: PropTypes.bool,
+  tabIndex: PropTypes.number,
+  componentDidUpdate: PropTypes.func,
+  onComponentUpdate: PropTypes.func,
+  className: PropTypes.string,
+  inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+};
+var ContentEditableBase = /*#__PURE__*/function (_Component) {
+  _inherits(ContentEditableBase, _Component);
+  var _super = _createSuper(ContentEditableBase);
+  function ContentEditableBase() {
+    _classCallCheck(this, ContentEditableBase);
+    return _super.apply(this, arguments);
+  }
+  _createClass(ContentEditableBase, [{
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps) {
+      return nextProps.disabled !== this.props.disabled || nextProps.__html !== this.props.__html;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      this.props.onComponentUpdate(prevProps);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        __html = _this$props.__html;
+        _this$props.onComponentUpdate;
+        var disabled = _this$props.disabled,
+        tabIndex = _this$props.tabIndex,
+        inputRef = _this$props.inputRef,
+        props = _objectWithoutProperties(_this$props, _excluded);
+      return /*#__PURE__*/React.createElement("div", _extends({}, props, {
+        ref: inputRef
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        ,
+        disabled: disabled,
+        role: "textbox",
+        tabIndex: disabled ? undefined : tabIndex,
+        contentEditable: !this.props.disabled,
+        dangerouslySetInnerHTML: {
+          __html
+        }
+      }));
+    }
+  }]);
+  return ContentEditableBase;
+}(Component);
+_defineProperty(ContentEditableBase, "propTypes", _objectSpread2(_objectSpread2({}, commonPropTypes), {}, {
+  __html: PropTypes.string
+}));
+_defineProperty(ContentEditableBase, "defaultProps", {
+  disabled: false,
+  tabIndex: 0,
+  onInput: noop,
+  onComponentUpdate: noop
+});
+var ContentEditable = function ContentEditable(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded2);
+  return /*#__PURE__*/React.createElement(ContentEditableBase, _extends({}, props, {
+    __html: renderToStaticMarkup(children)
+  }));
+};
+ContentEditable.propTypes = _objectSpread2(_objectSpread2({}, commonPropTypes), {}, {
+  children: PropTypes.node
+});
+
+export { ContentEditable as default };

package/components/control-label/control-label.d.ts

@@ -0,0 +1,11 @@
+import React, { LabelHTMLAttributes } from 'react';
+export declare enum LabelType {
+    SECONDARY = "secondary",
+    FORM = "form"
+}
+interface ControlLabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    disabled?: boolean;
+    type?: LabelType;
+}
+export declare const ControlLabel: React.FC<ControlLabelProps>;
+export default ControlLabel;

package/components/control-label/control-label.js

@@ -0,0 +1,36 @@
+import { e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+var modules_9eb96a10 = {"label":"label_rui_40a4","formLabel":"formLabel_rui_40a4","secondaryLabel":"secondaryLabel_rui_40a4","disabledLabel":"disabledLabel_rui_40a4"};
+
+var _excluded = ["children", "type", "disabled"];
+var LabelType;
+(function (LabelType) {
+  LabelType["SECONDARY"] = "secondary";
+  LabelType["FORM"] = "form";
+})(LabelType || (LabelType = {}));
+var classNameByType = {
+  [LabelType.SECONDARY]: modules_9eb96a10.secondaryLabel,
+  [LabelType.FORM]: modules_9eb96a10.formLabel
+};
+var ControlLabel = function ControlLabel(_ref) {
+  var children = _ref.children,
+    _ref$type = _ref.type,
+    type = _ref$type === void 0 ? LabelType.SECONDARY : _ref$type,
+    disabled = _ref.disabled,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("label", _extends({
+    className: classNames(modules_9eb96a10.label, classNameByType[type], {
+      [modules_9eb96a10.disabledLabel]: disabled
+    })
+  }, rest), children);
+};
+ControlLabel.propTypes = {
+  label: PropTypes.node,
+  labelStyle: PropTypes.string,
+  disabled: PropTypes.bool
+};
+
+export { ControlLabel, LabelType, ControlLabel as default };

package/components/data-list/data-list.d.ts

@@ -0,0 +1,85 @@
+/**
+  * @name Data List
+  */
+import React, { Component } from 'react';
+import { FocusSensorOuterProps } from '../global/focus-sensor-hoc';
+import { SelectionShortcutsAddProps, SelectionShortcutsOuterProps } from '../table/selection-shortcuts-hoc';
+import { DisableHoverAddProps } from '../table/disable-hover-hoc';
+import { SelectionItem } from '../table/selection';
+import { FormattedItem, moreLessButtonStates } from './item';
+export interface DataListBaseProps<T extends SelectionItem> {
+    data: readonly T[];
+    itemFormatter: (item: T) => FormattedItem<T>;
+    loading?: boolean | undefined;
+    onItemMoreLess?: ((item: T, more: boolean) => void) | undefined;
+    itemMoreLessState?: ((item: FormattedItem<T>) => moreLessButtonStates) | undefined;
+    remoteSelection?: boolean | undefined;
+    className?: string | null | undefined;
+    disabledHover?: boolean | null | undefined;
+}
+type FocusableProps<T extends SelectionItem> = DataListBaseProps<T> & DisableHoverAddProps & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsAddProps<T>;
+export type DataListContainerProps<T extends SelectionItem> = DataListBaseProps<T> & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsOuterProps<T>;
+export default class DataListContainer<T extends SelectionItem> extends Component<DataListContainerProps<T>> {
+    static propTypes: React.WeakValidationMap<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<SelectionItem, FocusableProps<SelectionItem>>> | undefined;
+    DataList: {
+        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>): {
+            state: {
+                disabledHover: boolean;
+            };
+            componentDidMount(): void;
+            componentWillUnmount(): void;
+            onMouseMove: () => void;
+            onKeyDown: (e: KeyboardEvent) => void;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>, context: any): {
+            state: {
+                disabledHover: boolean;
+            };
+            componentDidMount(): void;
+            componentWillUnmount(): void;
+            onMouseMove: () => void;
+            onKeyDown: (e: KeyboardEvent) => void;
+            render(): React.JSX.Element;
+            context: unknown;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        propTypes: React.WeakValidationMap<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
+        defaultProps: Partial<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
+        contextType?: React.Context<any> | undefined;
+    };
+    render(): React.JSX.Element;
+}
+export {};