@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/dist/tab-trap/tab-trap.d.ts

@@ -0,0 +1,43 @@
+import React, { Component, ReactNode, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export declare const FOCUSABLE_ELEMENTS = "input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])";
+export interface TabTrapProps extends HTMLAttributes<HTMLElement> {
+    children: ReactNode;
+    trapDisabled: boolean;
+    autoFocusFirst: boolean;
+    focusBackOnClose: boolean;
+    focusBackOnExit: boolean;
+}
+/**
+ * @name TabTrap
+ */
+export default class TabTrap extends Component<TabTrapProps> {
+    static propTypes: {
+        children: PropTypes.Validator<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        trapDisabled: PropTypes.Requireable<boolean>;
+        autoFocusFirst: PropTypes.Requireable<boolean>;
+        focusBackOnClose: PropTypes.Requireable<boolean>;
+        focusBackOnExit: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        trapDisabled: boolean;
+        autoFocusFirst: boolean;
+        focusBackOnClose: boolean;
+        focusBackOnExit: boolean;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    previousFocusedNode?: Element | null;
+    trapWithoutFocus?: boolean;
+    restoreFocus: () => void;
+    node?: HTMLElement | null;
+    containerRef: (node: HTMLElement | null) => void;
+    focusElement: (first?: boolean) => void;
+    focusFirst: () => void;
+    focusLast: () => void;
+    focusLastIfEnabled: (event: React.FocusEvent) => void;
+    handleBlurIfWithoutFocus: (event: React.FocusEvent) => void;
+    trapButtonNode?: HTMLElement | null;
+    trapButtonRef: (node: HTMLElement | null) => void;
+    render(): JSX.Element;
+}

package/dist/tab-trap/tab-trap.js

@@ -17,18 +17,24 @@ class TabTrap extends Component {
     super(...arguments);
     _this = this;
 
+    _defineProperty(this, "previousFocusedNode", void 0);
+
+    _defineProperty(this, "trapWithoutFocus", void 0);
+
     _defineProperty(this, "restoreFocus", () => {
       const {
         previousFocusedNode
       } = this;
 
-      if (previousFocusedNode && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
+      if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
         previousFocusedNode.focus({
           preventScroll: true
         });
       }
     });
 
+    _defineProperty(this, "node", void 0);
+
     _defineProperty(this, "containerRef", node => {
       if (!node) {
         return;
@@ -67,7 +73,7 @@ class TabTrap extends Component {
       if (this.props.focusBackOnExit) {
         const prevFocused = event.nativeEvent.relatedTarget;
 
-        if (prevFocused != null && this.node != null && this.node.contains(prevFocused)) {
+        if (prevFocused != null && this.node != null && prevFocused instanceof Element && this.node.contains(prevFocused)) {
           this.restoreFocus();
         }
       } else {
@@ -76,6 +82,8 @@ class TabTrap extends Component {
     });
 
     _defineProperty(this, "handleBlurIfWithoutFocus", event => {
+      var _this$node;
+
       if (!this.trapWithoutFocus) {
         return;
       }
@@ -87,13 +95,15 @@ class TabTrap extends Component {
         return;
       }
 
-      if (this.node.contains(newFocused)) {
+      if (newFocused instanceof Element && (_this$node = this.node) !== null && _this$node !== void 0 && _this$node.contains(newFocused)) {
         return;
       }
 
       this.focusLast();
     });
 
+    _defineProperty(this, "trapButtonNode", void 0);
+
     _defineProperty(this, "trapButtonRef", node => {
       if (!node) {
         return;
@@ -109,8 +119,10 @@ class TabTrap extends Component {
     if (this.props.autoFocusFirst) {
       this.focusFirst();
     } else if (!this.props.trapDisabled && (!this.node || !this.node.contains(this.previousFocusedNode))) {
+      var _this$trapButtonNode;
+
       this.trapWithoutFocus = true;
-      this.trapButtonNode.focus();
+      (_this$trapButtonNode = this.trapButtonNode) === null || _this$trapButtonNode === void 0 ? void 0 : _this$trapButtonNode.focus();
     }
   }
 

package/dist/table/cell.d.ts

@@ -0,0 +1,13 @@
+import { PureComponent, TdHTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface CellProps extends TdHTMLAttributes<HTMLTableDataCellElement> {
+    'data-test'?: string | null | undefined;
+}
+export default class Cell extends PureComponent<CellProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<any>;
+        className: PropTypes.Requireable<string>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    render(): JSX.Element;
+}

package/dist/table/disable-hover-hoc.d.ts

@@ -0,0 +1,68 @@
+import React, { ComponentType } from 'react';
+export interface DisableHoverAddProps {
+    disabledHover: boolean;
+}
+export declare type DisableHoverProps<P extends DisableHoverAddProps> = Omit<P, keyof DisableHoverAddProps>;
+export default function disableHoverHOC<P extends DisableHoverAddProps>(ComposedComponent: ComponentType<P>): {
+    new (props: DisableHoverProps<P> | Readonly<DisableHoverProps<P>>): {
+        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<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<DisableHoverProps<P>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: DisableHoverProps<P>, 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<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<DisableHoverProps<P>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<DisableHoverProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: React.WeakValidationMap<P> | undefined;
+    defaultProps: Partial<P> | undefined;
+    contextType?: React.Context<any> | undefined;
+};

package/dist/table/disable-hover-hoc.js

@@ -21,7 +21,7 @@ function disableHoverHOC(ComposedComponent) {
       });
 
       _defineProperty(this, "onKeyDown", e => {
-        const metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line no-magic-numbers
+        const metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line @typescript-eslint/no-magic-numbers
 
         if (!this.state.disabledHover && !metaKeys.includes(e.keyCode)) {
           this.setState({

package/dist/table/header-cell.d.ts

@@ -0,0 +1,43 @@
+import { PureComponent, ReactNode, SyntheticEvent, ThHTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface Column<T = never> {
+    id: string;
+    sortable?: boolean | null | undefined;
+    className?: string | null | undefined;
+    headerClassName?: string | null | undefined;
+    rightAlign?: boolean | null | undefined;
+    getHeaderValue?: (() => ReactNode) | null | undefined;
+    title?: ReactNode;
+    getValue?: ((item: T, column: Column) => ReactNode) | null | undefined;
+    getDataTest?: ((item: T, column: Column) => string) | null | undefined;
+}
+export interface SortParams {
+    column: Column;
+    order: boolean;
+}
+export interface HeaderCellProps extends ThHTMLAttributes<HTMLTableHeaderCellElement> {
+    column: Column;
+    onSort: (params: SortParams) => void;
+    sortKey?: string | null | undefined;
+    sortOrder?: boolean | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+export default class HeaderCell extends PureComponent<HeaderCellProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<any>;
+        className: PropTypes.Requireable<string>;
+        column: PropTypes.Validator<object>;
+        onSort: PropTypes.Requireable<(...args: any[]) => any>;
+        sortKey: PropTypes.Requireable<string>;
+        sortOrder: PropTypes.Requireable<boolean>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        onSort: () => void;
+    };
+    sortable?: boolean;
+    sorted?: boolean;
+    onClick: () => void;
+    onChildrenClick(e: SyntheticEvent): void;
+    render(): JSX.Element;
+}

package/dist/table/header-cell.js

@@ -17,6 +17,10 @@ class HeaderCell extends PureComponent {
   constructor() {
     super(...arguments);
 
+    _defineProperty(this, "sortable", void 0);
+
+    _defineProperty(this, "sorted", void 0);
+
     _defineProperty(this, "onClick", () => {
       if (this.sortable) {
         const {

package/dist/table/header.d.ts

@@ -0,0 +1,60 @@
+import { ChangeEventHandler, PureComponent, SyntheticEvent } from 'react';
+import PropTypes from 'prop-types';
+import { Waypoint } from 'react-waypoint';
+import { Column, SortParams } from './header-cell';
+export interface HeaderProps {
+    columns: readonly Column[];
+    selectable: boolean;
+    draggable: boolean;
+    checked: boolean;
+    sticky: boolean;
+    topStickOffset: string;
+    onSort: (params: SortParams) => void;
+    onCheckboxChange: ChangeEventHandler<HTMLInputElement>;
+    sortKey: string;
+    sortOrder: boolean;
+    caption?: string | null | undefined;
+    checkboxDisabled?: boolean | undefined;
+}
+export default class Header extends PureComponent<HeaderProps> {
+    static propTypes: {
+        caption: PropTypes.Requireable<string>;
+        selectable: PropTypes.Requireable<boolean>;
+        draggable: PropTypes.Requireable<boolean>;
+        checked: PropTypes.Requireable<boolean>;
+        checkboxDisabled: PropTypes.Requireable<boolean>;
+        sticky: PropTypes.Requireable<boolean>;
+        topStickOffset: PropTypes.Requireable<string>;
+        onCheckboxChange: PropTypes.Requireable<(...args: any[]) => any>;
+        columns: PropTypes.Validator<any[]>;
+        onSort: PropTypes.Requireable<(...args: any[]) => any>;
+        sortKey: PropTypes.Requireable<string>;
+        sortOrder: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        selectable: boolean;
+        draggable: boolean;
+        checked: boolean;
+        sticky: boolean;
+        topStickOffset: string;
+        onSort: () => void;
+        onCheckboxChange: () => void;
+        sortKey: string;
+        sortOrder: boolean;
+    };
+    state: {
+        fixed: boolean;
+        headerWidth: undefined;
+        widths: never[];
+    };
+    id: string;
+    onCheckboxFocus: (event: SyntheticEvent<HTMLElement>) => void;
+    private _columnsRowNode?;
+    storeColumnsRowNode: (node: HTMLElement | null) => void;
+    onScrollIn: () => void;
+    onScrollOut: ({ currentPosition }: Waypoint.CallbackArgs) => void;
+    calculateColumnsWidths(columnsRowNode: HTMLElement | null | undefined): void;
+    createCells(widths?: never[]): JSX.Element[];
+    render(): JSX.Element;
+}
+export declare type HeaderAttrs = JSX.LibraryManagedAttributes<typeof Header, HeaderProps>;

package/dist/table/header.js

@@ -26,16 +26,18 @@ class Header extends PureComponent {
 
     _defineProperty(this, "state", {
       fixed: false,
-      headerWidth: null,
+      headerWidth: undefined,
       widths: []
     });
 
     _defineProperty(this, "id", getUID('table-header-'));
 
     _defineProperty(this, "onCheckboxFocus", event => {
-      event.target.blur();
+      event.currentTarget.blur();
     });
 
+    _defineProperty(this, "_columnsRowNode", void 0);
+
     _defineProperty(this, "storeColumnsRowNode", node => {
       if (node) {
         this._columnsRowNode = node;
@@ -67,9 +69,11 @@ class Header extends PureComponent {
   }
 
   calculateColumnsWidths(columnsRowNode) {
+    var _columnsRowNode$child;
+
     this.setState({
-      headerWidth: columnsRowNode.clientWidth,
-      widths: [...columnsRowNode.childNodes].map(column => column.clientWidth)
+      headerWidth: columnsRowNode === null || columnsRowNode === void 0 ? void 0 : columnsRowNode.clientWidth,
+      widths: [...((_columnsRowNode$child = columnsRowNode === null || columnsRowNode === void 0 ? void 0 : columnsRowNode.childNodes) !== null && _columnsRowNode$child !== void 0 ? _columnsRowNode$child : [])].map(column => column instanceof Element ? column.clientWidth : 0)
     });
   }
 
@@ -99,7 +103,7 @@ class Header extends PureComponent {
     return columns.map((column, index) => {
       const columnStyle = widths[index] ? {
         width: widths[index]
-      } : null;
+      } : undefined;
       const props = {
         column,
         onSort,

package/dist/table/multitable.d.ts

@@ -0,0 +1,25 @@
+import { PureComponent, ReactElement } from 'react';
+import PropTypes from 'prop-types';
+import { TableAttrs } from './table';
+import { SelectionItem } from './selection';
+export interface MultiTableProps {
+    children: ReactElement<TableAttrs<SelectionItem>>[];
+}
+export default class MultiTable extends PureComponent<MultiTableProps> {
+    static propTypes: {
+        children: PropTypes.Validator<any>;
+    };
+    componentDidUpdate(prevProps: MultiTableProps): void;
+    onUpPress: () => boolean;
+    onDownPress: () => boolean;
+    onEscPress: () => void;
+    onCmdAPress: () => boolean;
+    shortcuts: {
+        up: () => boolean;
+        down: () => boolean;
+        esc: () => void;
+        'command+a': () => boolean;
+        'ctrl+a': () => boolean;
+    };
+    render(): JSX.Element;
+}

package/dist/table/multitable.js

@@ -23,13 +23,19 @@ class MultiTable extends PureComponent {
       let newSelection = currentTable.selection.moveUp();
 
       if (newSelection) {
-        currentTable.onSelect(newSelection);
+        var _currentTable$onSelec;
+
+        (_currentTable$onSelec = currentTable.onSelect) === null || _currentTable$onSelec === void 0 ? void 0 : _currentTable$onSelec.call(currentTable, newSelection);
       } else if (prevTable) {
-        currentTable.onSelect(currentTable.selection.resetFocus());
+        var _currentTable$onSelec2;
+
+        (_currentTable$onSelec2 = currentTable.onSelect) === null || _currentTable$onSelec2 === void 0 ? void 0 : _currentTable$onSelec2.call(currentTable, currentTable.selection.resetFocus());
         newSelection = prevTable.selection.moveUp();
 
         if (newSelection) {
-          prevTable.onSelect(newSelection);
+          var _prevTable$onSelect;
+
+          (_prevTable$onSelect = prevTable.onSelect) === null || _prevTable$onSelect === void 0 ? void 0 : _prevTable$onSelect.call(prevTable, newSelection);
         }
       }
 
@@ -53,13 +59,19 @@ class MultiTable extends PureComponent {
       let newSelection = currentTable.selection.moveDown();
 
       if (newSelection) {
-        currentTable.onSelect(newSelection);
+        var _currentTable$onSelec3;
+
+        (_currentTable$onSelec3 = currentTable.onSelect) === null || _currentTable$onSelec3 === void 0 ? void 0 : _currentTable$onSelec3.call(currentTable, newSelection);
       } else if (nextTable) {
-        currentTable.onSelect(currentTable.selection.resetFocus());
+        var _currentTable$onSelec4;
+
+        (_currentTable$onSelec4 = currentTable.onSelect) === null || _currentTable$onSelec4 === void 0 ? void 0 : _currentTable$onSelec4.call(currentTable, currentTable.selection.resetFocus());
         newSelection = nextTable.selection.moveDown();
 
         if (newSelection) {
-          nextTable.onSelect(newSelection);
+          var _nextTable$onSelect;
+
+          (_nextTable$onSelect = nextTable.onSelect) === null || _nextTable$onSelect === void 0 ? void 0 : _nextTable$onSelect.call(nextTable, newSelection);
         }
       }
 
@@ -115,7 +127,9 @@ class MultiTable extends PureComponent {
       const currentFocused = currentSelections.filter(selection => selection.getFocused());
 
       if (currentFocused.includes(prevFocused)) {
-        prevProps.children[prevFocusedIndex].props.onSelect(prevFocused.resetFocus());
+        var _prevProps$children$p, _prevProps$children$p2;
+
+        (_prevProps$children$p = (_prevProps$children$p2 = prevProps.children[prevFocusedIndex].props).onSelect) === null || _prevProps$children$p === void 0 ? void 0 : _prevProps$children$p.call(_prevProps$children$p2, prevFocused.resetFocus());
       }
     }
   }

package/dist/table/row-with-focus-sensor.d.ts

@@ -0,0 +1,18 @@
+import React, { PureComponent } from 'react';
+import { FocusSensorProps } from '../global/focus-sensor-hoc';
+import Row, { RowProps } from './row';
+import { SelectionItem } from './selection';
+export interface RowWithFocusSensorCallbacksProps<T extends SelectionItem> extends Omit<FocusSensorProps<RowProps<T>, HTMLTableRowElement, typeof Row>, 'onFocus'> {
+    onFocus: (item: T) => void;
+    onSelect: (item: T, selected: boolean) => void;
+    onCollapse: (item: T) => void;
+    onExpand: (item: T) => void;
+}
+export default class RowWithFocusSensorCallbacks<T extends SelectionItem> extends PureComponent<RowWithFocusSensorCallbacksProps<T>> {
+    RowWithFocusSensor: React.ComponentType<FocusSensorProps<RowProps<T>, HTMLDivElement, typeof Row>>;
+    onFocus: () => void;
+    onSelect: (item: T, selected: boolean) => void;
+    onCollapse: () => void;
+    onExpand: () => void;
+    render(): JSX.Element;
+}

package/dist/table/row-with-focus-sensor.js

@@ -3,6 +3,7 @@ import React, { PureComponent } from 'react';
 import focusSensorHOC from '../global/focus-sensor-hoc.js';
 import Row from './row.js';
 import 'prop-types';
+import '../global/prop-types.js';
 import '../global/composeRefs.js';
 import 'classnames';
 import '@jetbrains/icons/chevron-right';
@@ -43,11 +44,14 @@ import '../popup/popup.target.js';
 import './cell.js';
 import '../_helpers/table.js';
 
-const RowWithFocusSensor = focusSensorHOC(Row);
+const getContainer = () => focusSensorHOC(Row);
+
 class RowWithFocusSensorCallbacks extends PureComponent {
   constructor() {
     super(...arguments);
 
+    _defineProperty(this, "RowWithFocusSensor", getContainer());
+
     _defineProperty(this, "onFocus", () => {
       this.props.onFocus(this.props.item);
     });
@@ -66,7 +70,7 @@ class RowWithFocusSensorCallbacks extends PureComponent {
   }
 
   render() {
-    return /*#__PURE__*/React.createElement(RowWithFocusSensor, _extends({}, this.props, {
+    return /*#__PURE__*/React.createElement(this.RowWithFocusSensor, _extends({}, this.props, {
       onFocus: this.onFocus,
       onSelect: this.onSelect,
       onCollapse: this.onCollapse,
@@ -75,7 +79,6 @@ class RowWithFocusSensorCallbacks extends PureComponent {
   }
 
 }
-
-_defineProperty(RowWithFocusSensorCallbacks, "propTypes", Row.propTypes);
+RowWithFocusSensorCallbacks.propTypes = Row.propTypes;
 
 export { RowWithFocusSensorCallbacks as default };

package/dist/table/row.d.ts

@@ -0,0 +1,56 @@
+import React, { HTMLAttributes, PureComponent } from 'react';
+import { FocusSensorAddProps } from '../global/focus-sensor-hoc';
+import { Column } from './header-cell';
+import { SelectionItem } from './selection';
+export interface RowProps<T extends SelectionItem> extends Omit<HTMLAttributes<HTMLTableRowElement>, 'onClick' | 'onDoubleClick' | 'onSelect'>, FocusSensorAddProps<HTMLTableRowElement> {
+    item: T;
+    columns: readonly Column<T>[];
+    selectable: boolean;
+    showFocus: boolean;
+    draggable: boolean;
+    alwaysShowDragHandle: boolean;
+    selected: boolean;
+    onHover: (item: T, e: React.MouseEvent<HTMLTableRowElement>) => void;
+    onSelect: (item: T, selected: boolean) => void;
+    onDoubleClick: (item: T) => void;
+    onClick: (item: T, e: React.MouseEvent<HTMLTableRowElement>) => void;
+    level: number;
+    collapsible: boolean;
+    parentCollapsible: boolean;
+    collapsed: boolean;
+    onCollapse: (item: T) => void;
+    onExpand: (item: T) => void;
+    showDisabledSelection?: boolean | null | undefined;
+    checkboxTooltip?: string | undefined;
+    autofocus?: boolean | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+export default class Row<T extends SelectionItem> extends PureComponent<RowProps<T>> {
+    static defaultProps: {
+        selectable: boolean;
+        showFocus: boolean;
+        draggable: boolean;
+        alwaysShowDragHandle: boolean;
+        selected: boolean;
+        onHover: () => void;
+        onSelect: () => void;
+        onDoubleClick: () => void;
+        onClick: () => void;
+        level: number;
+        collapsible: boolean;
+        parentCollapsible: boolean;
+        collapsed: boolean;
+        onCollapse: () => void;
+        onExpand: () => void;
+    };
+    id: string;
+    onMouseEnter: (e: React.MouseEvent<HTMLTableRowElement>) => void;
+    onClick: (e: React.MouseEvent<HTMLTableRowElement>) => void;
+    onCheckboxFocus: () => void;
+    onCheckboxChange: () => void;
+    toggleSelection(): void;
+    onDoubleClick: () => void;
+    row?: HTMLElement | null;
+    rowRef: (el: HTMLElement | null) => void;
+    render(): JSX.Element;
+}