@jetbrains/ring-ui 6.0.6-beta.0 → 6.0.6

package/components/content-layout/content-layout.css

@@ -0,0 +1,108 @@
+@import "../global/variables.css";
+
+@value extra-small-screen-media, small-screen-media from "../global/global.css";
+@value sidebarWidth: calc(var(--ring-unit) * 30);
+
+.contentLayout {
+  position: relative;
+
+  display: flex;
+  flex-flow: row nowrap;
+}
+
+.contentLayoutContent {
+  align-self: flex-start;
+  flex-grow: 2;
+
+  width: 100%; /* without this hack IE11 render contentLayoutContent wider than its container */
+  margin: 0 calc(var(--ring-unit) * 4);
+}
+
+.sidebarContainer {
+  min-width: sidebarWidth;
+  max-width: sidebarWidth;
+}
+
+.sidebarContainerRight {
+  order: 1;
+}
+
+.sidebar {
+  overflow: auto;
+
+  box-sizing: border-box;
+  min-width: sidebarWidth;
+  max-width: sidebarWidth;
+  height: 100%;
+  padding-right: calc(var(--ring-unit) * 2);
+  padding-left: calc(var(--ring-unit) * 4);
+}
+
+.sidebarRight {
+  padding-right: calc(var(--ring-unit) * 4);
+  padding-left: calc(var(--ring-unit) * 2);
+}
+
+.sidebarFixedTop {
+  top: 0;
+  bottom: 0;
+
+  &.sidebarFixedTop {
+    position: fixed;
+  }
+}
+
+.sidebarFixedBottom.sidebarFixedBottom {
+  position: absolute;
+  top: auto;
+  bottom: 0;
+}
+
+.bottomMarker {
+  position: absolute;
+  bottom: 0;
+}
+
+.contentLayoutResponsive {
+  @media extra-small-screen-media, small-screen-media {
+    & .contentLayoutContent {
+      margin: 0 16px;
+    }
+
+    & .sidebar {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      left: 0;
+
+      box-sizing: content-box;
+      padding: 0 16px;
+    }
+
+    & .sidebarFixedTop {
+      position: fixed;
+    }
+
+    & .sidebarFixedBottom {
+      top: auto;
+    }
+
+    & .sidebarRight {
+      right: 0;
+      left: auto;
+    }
+
+    & .sidebarContainer {
+      min-width: 0;
+      max-width: 0;
+    }
+  }
+
+  @media extra-small-screen-media {
+    & .sidebar {
+      width: 80%;
+      min-width: 0;
+      max-width: none;
+    }
+  }
+}

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,45 @@
+import React, { cloneElement, Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Sidebar from './sidebar';
+import styles from './content-layout.css';
+/**
+ * @name Content Layout
+ */
+export default class ContentLayout extends Component {
+    static propTypes = {
+        children: PropTypes.node,
+        className: PropTypes.string,
+        contentClassName: PropTypes.string,
+        responsive: PropTypes.bool
+    };
+    static defaultProps = {
+        responsive: true
+    };
+    state = {
+        contentNode: null
+    };
+    saveContentNode = (contentNode) => {
+        this.setState({ contentNode });
+    };
+    render() {
+        const { children, className, contentClassName, responsive, ...restProps } = this.props;
+        const classes = classNames(styles.contentLayout, className, {
+            [styles.contentLayoutResponsive]: responsive
+        });
+        const contentClasses = classNames(styles.contentLayoutContent, contentClassName);
+        const childrenArray = React.Children.toArray(children);
+        const sidebarChild = childrenArray.filter((child) => child != null && typeof child === 'object' && 'type' in child && child.type === Sidebar)[0];
+        const sidebar = sidebarChild && cloneElement(sidebarChild, {
+            contentNode: this.state.contentNode
+        });
+        const contentChildren = childrenArray.filter(child => child !== sidebarChild);
+        return (<div {...restProps} className={classes}>
+        {sidebar}
+        <main className={contentClasses} ref={this.saveContentNode}>
+          {contentChildren}
+        </main>
+      </div>);
+    }
+}
+export { default as Sidebar } from './sidebar';

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,76 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Waypoint } from 'react-waypoint';
+import styles from './content-layout.css';
+const ABOVE = 'above';
+const INSIDE = 'inside';
+export default class Sidebar extends Component {
+    static propTypes = {
+        right: PropTypes.bool,
+        children: PropTypes.node,
+        className: PropTypes.string,
+        containerClassName: PropTypes.string,
+        fixedClassName: PropTypes.string,
+        contentNode: PropTypes.object
+    };
+    state = {
+        topIsOutside: true,
+        bottomIsOutside: true,
+        sidebarVisibleHeight: undefined
+    };
+    sidebarNode;
+    handleTopWaypoint = ({ currentPosition }) => {
+        this.setState({ topIsOutside: currentPosition === ABOVE });
+    };
+    handleBottomWaypoint = ({ currentPosition, waypointTop }) => {
+        this.setState({
+            sidebarVisibleHeight: waypointTop,
+            bottomIsOutside: currentPosition !== INSIDE
+        });
+    };
+    shouldUseFixation() {
+        const { contentNode } = this.props;
+        const { sidebarNode } = this;
+        if (!contentNode || !sidebarNode) {
+            return false;
+        }
+        return contentNode.offsetHeight >= sidebarNode.offsetHeight;
+    }
+    shouldFixateBottom() {
+        const { topIsOutside, bottomIsOutside } = this.state;
+        return !bottomIsOutside && topIsOutside && this.shouldUseFixation();
+    }
+    sidebarRef = (node) => {
+        this.sidebarNode = node;
+    };
+    render() {
+        const { right, children, className, containerClassName, fixedClassName, contentNode, ...restProps } = this.props;
+        const { topIsOutside, bottomIsOutside, sidebarVisibleHeight } = this.state;
+        const shouldFixateTop = bottomIsOutside && topIsOutside && this.shouldUseFixation();
+        const shouldFixateBottom = this.shouldFixateBottom();
+        const containerClasses = classNames(styles.sidebarContainer, containerClassName, {
+            [styles.sidebarContainerRight]: right
+        });
+        const classes = classNames(styles.sidebar, className, {
+            [styles.sidebarRight]: right,
+            [styles.sidebarFixedTop]: shouldFixateTop,
+            [styles.sidebarFixedBottom]: shouldFixateBottom,
+            [fixedClassName ?? '']: shouldFixateTop || shouldFixateBottom
+        });
+        const style = {
+            maxHeight: shouldFixateBottom && sidebarVisibleHeight ? `${sidebarVisibleHeight}px` : undefined
+        };
+        return (<aside className={containerClasses} ref={this.sidebarRef}>
+        <Waypoint onEnter={this.handleTopWaypoint} onLeave={this.handleTopWaypoint}/>
+
+        <div {...restProps} style={style} className={classes}>
+          {children}
+        </div>
+
+        <div className={styles.bottomMarker}>
+          <Waypoint onEnter={this.handleBottomWaypoint} onLeave={this.handleBottomWaypoint}/>
+        </div>
+      </aside>);
+    }
+}

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,47 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { renderToStaticMarkup } from 'react-dom/server';
+/**
+ * @name ContentEditable
+ */
+function noop() { }
+const commonPropTypes = {
+    disabled: PropTypes.bool,
+    tabIndex: PropTypes.number,
+    componentDidUpdate: PropTypes.func,
+    onComponentUpdate: PropTypes.func,
+    className: PropTypes.string,
+    inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+};
+class ContentEditableBase extends Component {
+    static propTypes = {
+        ...commonPropTypes,
+        __html: PropTypes.string
+    };
+    static defaultProps = {
+        disabled: false,
+        tabIndex: 0,
+        onInput: noop,
+        onComponentUpdate: noop
+    };
+    shouldComponentUpdate(nextProps) {
+        return nextProps.disabled !== this.props.disabled ||
+            nextProps.__html !== this.props.__html;
+    }
+    componentDidUpdate(prevProps) {
+        this.props.onComponentUpdate(prevProps);
+    }
+    render() {
+        const { __html, onComponentUpdate, disabled, tabIndex, inputRef, ...props } = this.props;
+        return (<div {...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 }}/>);
+    }
+}
+const ContentEditable = ({ children, ...props }) => <ContentEditableBase {...props} __html={renderToStaticMarkup(children)}/>;
+ContentEditable.propTypes = {
+    ...commonPropTypes,
+    children: PropTypes.node
+};
+export default ContentEditable;

package/components/control-label/control-label.css

@@ -0,0 +1,23 @@
+.label {
+  display: block;
+
+  margin-bottom: calc(var(--ring-unit) * 0.5);
+}
+
+.formLabel {
+  color: var(--ring-text-color);
+
+  font-size: var(--ring-font-size);
+  line-height: var(--ring-line-height);
+}
+
+.secondaryLabel {
+  color: var(--ring-secondary-color);
+
+  font-size: var(--ring-font-size-smaller);
+  line-height: var(--ring-line-height-lowest);
+}
+
+.disabledLabel {
+  color: var(--ring-disabled-color);
+}

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,22 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import styles from './control-label.css';
+export var LabelType;
+(function (LabelType) {
+    LabelType["SECONDARY"] = "secondary";
+    LabelType["FORM"] = "form";
+})(LabelType || (LabelType = {}));
+const classNameByType = {
+    [LabelType.SECONDARY]: styles.secondaryLabel,
+    [LabelType.FORM]: styles.formLabel
+};
+export const ControlLabel = ({ children, type = LabelType.SECONDARY, disabled, ...rest }) => (<label className={classNames(styles.label, classNameByType[type], {
+        [styles.disabledLabel]: disabled
+    })} {...rest}>{children}</label>);
+ControlLabel.propTypes = {
+    label: PropTypes.node,
+    labelStyle: PropTypes.string,
+    disabled: PropTypes.bool
+};
+export default ControlLabel;

package/components/data-list/data-list.css

@@ -0,0 +1,97 @@
+@import "../global/variables.css";
+
+@value height, compensate from "../table/table.css";
+
+.dataListWrapper {
+  position: relative;
+}
+
+.dataList {
+  margin: 0;
+  padding: 0;
+
+  list-style: none;
+}
+
+.itemContent {
+  padding: 0;
+
+  list-style: none;
+}
+
+.title {
+  display: flex;
+  align-items: center;
+
+  box-sizing: content-box;
+  height: calc(4 * var(--ring-unit));
+  padding: 0 calc(var(--ring-unit) * 5) compensate 0;
+
+  outline: none;
+
+  /* stylelint-disable-next-line selector-max-specificity */
+  .dataList:not(.disabledHover) &:hover {
+    background-color: var(--ring-hover-background-color);
+  }
+
+  &.titleSelected {
+    background-color: var(--ring-selected-background-color);
+  }
+
+  &.titleFocused {
+    background-color: var(--ring-hover-background-color);
+    box-shadow: inset 2px 0 var(--ring-main-color);
+  }
+}
+
+.showMore {
+  padding: 4px 60px;
+
+  color: var(--ring-secondary-color);
+  outline: none;
+
+  font-size: 12px;
+}
+
+.boxes {
+  display: flex;
+
+  min-width: calc(var(--ring-unit) * 3);
+}
+
+.checkboxBox {
+  width: calc(var(--ring-unit) * 3);
+}
+
+.collapseButton {
+  top: 1px;
+  left: -5px;
+
+  height: auto;
+  padding: 0 5px;
+
+  line-height: inherit;
+}
+
+.collapseIcon.collapseIcon {
+  color: var(--ring-icon-secondary-color);
+}
+
+.loadingOverlay {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+
+  display: flex;
+  align-items: center;
+  justify-content: center;
+
+  background-color: rgba(255, 255, 255, 0.5);
+}
+
+.showMoreLoader {
+  top: 1px;
+  left: 8px;
+}

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 {};