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

package/dist/link/link.d.ts

@@ -0,0 +1,157 @@
+import 'focus-visible';
+import React, { ReactNode, ComponentType } from 'react';
+import PropTypes from 'prop-types';
+import { ClickableLinkProps } from './clickableLink';
+export declare function setCompatibilityMode(isEnabled: boolean): void;
+export interface WrapTextProps {
+    children: ReactNode;
+    className?: string | null | undefined;
+}
+declare type ChildrenFunction = (WrapText: ComponentType<WrapTextProps>) => ReactNode;
+export interface LinkBaseProps {
+    active?: boolean | null | undefined;
+    inherit?: boolean | null | undefined;
+    pseudo?: boolean | null | undefined;
+    hover?: boolean | null | undefined;
+    innerClassName?: string | null | undefined;
+    'data-test'?: string | null | undefined;
+    children: ReactNode | ChildrenFunction;
+}
+export declare type LinkProps<P extends ClickableLinkProps = ClickableLinkProps> = Omit<P, keyof LinkBaseProps> & LinkBaseProps;
+export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent: ComponentType<P> | string): {
+    new (props: LinkProps<P> | Readonly<LinkProps<P>>): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<P>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: LinkProps<P>, context: any): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<P>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        innerClassName: PropTypes.Requireable<string>;
+        active: PropTypes.Requireable<boolean>;
+        inherit: PropTypes.Requireable<boolean>;
+        pseudo: PropTypes.Requireable<boolean>;
+        hover: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        'data-test': PropTypes.Requireable<string>;
+        href: PropTypes.Requireable<string>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+declare const _default: {
+    new (props: LinkProps<ClickableLinkProps> | Readonly<LinkProps<ClickableLinkProps>>): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<ClickableLinkProps>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: LinkProps<ClickableLinkProps>, context: any): {
+        getChildren(): React.ReactNode;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<ClickableLinkProps>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        innerClassName: PropTypes.Requireable<string>;
+        active: PropTypes.Requireable<boolean>;
+        inherit: PropTypes.Requireable<boolean>;
+        pseudo: PropTypes.Requireable<boolean>;
+        hover: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        'data-test': PropTypes.Requireable<string>;
+        href: PropTypes.Requireable<string>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/link/link.js

@@ -17,7 +17,7 @@ function setCompatibilityMode(isEnabled) {
   isCompatibilityMode = isEnabled;
 }
 const makeWrapText = memoize(innerClassName => {
-  const WrapText = /*#__PURE__*/memo(function WrapText(_ref) {
+  function WrapText(_ref) {
     let {
       className,
       children
@@ -26,12 +26,13 @@ const makeWrapText = memoize(innerClassName => {
     return /*#__PURE__*/React.createElement("span", {
       className: classes
     }, children);
-  });
+  }
+
   WrapText.propTypes = {
     className: PropTypes.string,
     children: PropTypes.node
   };
-  return WrapText;
+  return /*#__PURE__*/memo(WrapText);
 });
 function linkHOC(ComposedComponent) {
   var _class, _temp;
@@ -60,7 +61,7 @@ function linkHOC(ComposedComponent) {
         children,
         onPlainLeftClick,
         onClick,
-        ...props
+        ...restProps
       } = this.props;
       const useButton = pseudo || !isCustom && href == null;
       const classes = classNames(modules_607b0772.link, className, {
@@ -71,9 +72,12 @@ function linkHOC(ComposedComponent) {
         [modules_607b0772.pseudo]: useButton,
         [modules_607b0772.text]: typeof children !== 'function'
       });
+      let props = restProps;
 
       if (isCustom && !props.activeClassName) {
-        props.activeClassName = modules_607b0772.active;
+        props = { ...props,
+          activeClassName: modules_607b0772.active
+        };
       }
 
       if (useButton) {

package/dist/list/consts.d.ts

@@ -0,0 +1,74 @@
+import React, { ComponentType, ReactNode, SyntheticEvent } from 'react';
+import { LinkProps } from '../link/link';
+import { IconType, Size } from '../icon/icon';
+/**
+ * @enum {number}
+ */
+export declare enum Type {
+    SEPARATOR = 0,
+    LINK = 1,
+    ITEM = 2,
+    HINT = 3,
+    CUSTOM = 4,
+    TITLE = 5,
+    MARGIN = 6
+}
+export declare enum Dimension {
+    ITEM_PADDING = 16,
+    ITEM_HEIGHT = 32,
+    COMPACT_ITEM_HEIGHT = 24,
+    SEPARATOR_HEIGHT = 25,
+    SEPARATOR_FIRST_HEIGHT = 16,
+    SEPARATOR_TEXT_HEIGHT = 18,
+    TITLE_HEIGHT = 42,
+    INNER_PADDING = 8,
+    MARGIN = 8
+}
+export declare const DEFAULT_ITEM_TYPE = Type.ITEM;
+export declare type ListDataItem<T = unknown> = T & Partial<Omit<LinkProps, 'onClick' | 'onMouseUp'>> & {
+    rgItemType?: Type | null | undefined;
+    key?: string | number | null | undefined;
+    disabled?: boolean | undefined;
+    details?: string | null | undefined;
+    hoverClassName?: string | null | undefined;
+    compact?: boolean | null | undefined;
+    className?: string | null | undefined;
+    url?: string | undefined;
+    showGeneratedAvatar?: boolean | null | undefined;
+    username?: string | null | undefined;
+    avatar?: string | null | undefined;
+    subavatar?: string | null | undefined;
+    glyph?: IconType | string | null | undefined;
+    icon?: string | undefined;
+    iconSize?: Size | null | undefined;
+    rightGlyph?: IconType | string | null | undefined;
+    title?: string | null | undefined;
+    level?: number | null | undefined;
+    checkbox?: boolean | undefined;
+    description?: ReactNode;
+    label?: ReactNode;
+    rightNodes?: ReactNode;
+    leftNodes?: ReactNode;
+    tagName?: keyof JSX.IntrinsicElements | null | undefined;
+    selectedLabel?: string | null | undefined;
+    originalModel?: never;
+    LinkComponent?: ComponentType<LinkProps> | string | null | undefined;
+    template?: ReactNode | ((props: ListDataItemProps<T>) => ReactNode);
+    onClick?: ((item: ListDataItem<T>, event: Event | SyntheticEvent) => void) | null | undefined;
+    onMouseUp?: ((item: ListDataItem<T>, event: Event | SyntheticEvent) => void) | null | undefined;
+};
+export interface ListDataItemAddProps {
+    className?: string;
+    compact?: boolean | null | undefined;
+    hover: boolean;
+    onMouseOver: (e: SyntheticEvent) => void;
+    tabIndex: number;
+    scrolling: boolean;
+    onMouseUp?: (e: React.MouseEvent) => void;
+    onMouseDown?: (e: React.MouseEvent) => void;
+    onClick: (e: SyntheticEvent) => void;
+    onCheckboxChange: (e: React.ChangeEvent) => void;
+    isFirst?: boolean;
+    'data-test'?: string | null | undefined;
+}
+export declare type ListDataItemProps<T = unknown> = Omit<ListDataItem<T>, keyof ListDataItemAddProps> & ListDataItemAddProps;

package/dist/list/consts.js

@@ -1,26 +1,32 @@
 /**
  * @enum {number}
  */
-const Type = {
-  SEPARATOR: 0,
-  LINK: 1,
-  ITEM: 2,
-  HINT: 3,
-  CUSTOM: 4,
-  TITLE: 5,
-  MARGIN: 6
-};
-const Dimension = {
-  ITEM_PADDING: 16,
-  ITEM_HEIGHT: 32,
-  COMPACT_ITEM_HEIGHT: 24,
-  SEPARATOR_HEIGHT: 25,
-  SEPARATOR_FIRST_HEIGHT: 16,
-  SEPARATOR_TEXT_HEIGHT: 18,
-  TITLE_HEIGHT: 42,
-  INNER_PADDING: 8,
-  MARGIN: 8
-};
+var Type;
+
+(function (Type) {
+  Type[Type["SEPARATOR"] = 0] = "SEPARATOR";
+  Type[Type["LINK"] = 1] = "LINK";
+  Type[Type["ITEM"] = 2] = "ITEM";
+  Type[Type["HINT"] = 3] = "HINT";
+  Type[Type["CUSTOM"] = 4] = "CUSTOM";
+  Type[Type["TITLE"] = 5] = "TITLE";
+  Type[Type["MARGIN"] = 6] = "MARGIN";
+})(Type || (Type = {}));
+
+var Dimension;
+
+(function (Dimension) {
+  Dimension[Dimension["ITEM_PADDING"] = 16] = "ITEM_PADDING";
+  Dimension[Dimension["ITEM_HEIGHT"] = 32] = "ITEM_HEIGHT";
+  Dimension[Dimension["COMPACT_ITEM_HEIGHT"] = 24] = "COMPACT_ITEM_HEIGHT";
+  Dimension[Dimension["SEPARATOR_HEIGHT"] = 25] = "SEPARATOR_HEIGHT";
+  Dimension[Dimension["SEPARATOR_FIRST_HEIGHT"] = 16] = "SEPARATOR_FIRST_HEIGHT";
+  Dimension[Dimension["SEPARATOR_TEXT_HEIGHT"] = 18] = "SEPARATOR_TEXT_HEIGHT";
+  Dimension[Dimension["TITLE_HEIGHT"] = 42] = "TITLE_HEIGHT";
+  Dimension[Dimension["INNER_PADDING"] = 8] = "INNER_PADDING";
+  Dimension[Dimension["MARGIN"] = 8] = "MARGIN";
+})(Dimension || (Dimension = {}));
+
 const DEFAULT_ITEM_TYPE = Type.ITEM;
 
 export { DEFAULT_ITEM_TYPE, Dimension, Type };

package/dist/list/list.d.ts

@@ -0,0 +1,191 @@
+/**
+ * @name List
+ */
+import React, { Component, ReactNode, SyntheticEvent } from 'react';
+import PropTypes from 'prop-types';
+import VirtualizedList, { ListRowProps } from 'react-virtualized/dist/es/List';
+import { Size } from 'react-virtualized/dist/es/AutoSizer';
+import { WindowScrollerChildProps } from 'react-virtualized/dist/es/WindowScroller';
+import { ShortcutsMap } from '../shortcuts/core';
+import ListHint from './list__hint';
+import { Dimension, ListDataItem, ListDataItemProps, Type } from './consts';
+declare function noop(): void;
+/**
+ * @param {Type} listItemType
+ * @param {Object} item list item
+ */
+declare function isItemType<T>(listItemType: Type, item: ListDataItem<T>): boolean;
+export interface SelectHandlerParams {
+    tryKeepOpen?: boolean;
+}
+export interface ListProps<T = unknown> {
+    data: readonly ListDataItem<T>[];
+    restoreActiveIndex: boolean;
+    activateSingleItem: boolean;
+    activateFirstItem: boolean;
+    onMouseOut: (e: SyntheticEvent) => void;
+    onSelect: (item: ListDataItem<T>, event: Event | SyntheticEvent, params?: SelectHandlerParams) => void;
+    onScrollToBottom: () => void;
+    onResize: (info: Size) => void;
+    shortcuts: boolean;
+    renderOptimization: boolean;
+    disableMoveDownOverflow: boolean;
+    ariaLabel: string;
+    id?: string | undefined;
+    className?: string | null | undefined;
+    hint?: ReactNode;
+    hintOnSelection?: string | null | undefined;
+    maxHeight?: number | null | undefined;
+    activeIndex?: number | null | undefined;
+    useMouseUp?: boolean | null | undefined;
+    visible?: boolean | null | undefined;
+    disableMoveOverflow?: boolean | null | undefined;
+    compact?: boolean | null | undefined;
+    disableScrollToActive?: boolean | null | undefined;
+    hidden?: boolean | null | undefined;
+}
+export declare const ActiveItemContext: {
+    ValueContext: React.Context<string | undefined>;
+    UpdateContext: React.Context<(value: string | undefined) => void>;
+    Provider: {
+        ({ children }: import("../global/create-stateful-context").ProviderProps): JSX.Element;
+        propTypes: {
+            children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        };
+        displayName: string;
+    };
+    useUpdate: (value: string | undefined, skipUpdate?: boolean | undefined) => void;
+    Updater: React.MemoExoticComponent<{
+        ({ value, skipUpdate }: import("../global/create-stateful-context").UpdaterProps<string | undefined>): null;
+        displayName: string;
+    }>;
+};
+export interface ListState<T = unknown> {
+    activeIndex: number | null;
+    prevActiveIndex: number | null;
+    prevData: ListDataItem<T>[];
+    activeItem: ListDataItem<T> | null;
+    needScrollToActive: boolean;
+    scrolling: boolean;
+    hasOverflow: boolean;
+    disabledHover: boolean;
+    scrolledToBottom: boolean;
+}
+interface RenderVirtualizedInnerParams extends Partial<WindowScrollerChildProps> {
+    height: number;
+    maxHeight?: number;
+    autoHeight?: boolean;
+    rowCount: number;
+}
+/**
+ * @name List
+ * @constructor
+ * @extends {ReactComponent}
+ */
+/**
+ * Displays a list of items.
+ */
+export default class List<T = unknown> extends Component<ListProps<T>, ListState<T>> {
+    static propTypes: {
+        id: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        hint: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        hintOnSelection: PropTypes.Requireable<string>;
+        data: PropTypes.Requireable<any[]>;
+        maxHeight: PropTypes.Requireable<number>;
+        activeIndex: PropTypes.Requireable<number>;
+        restoreActiveIndex: PropTypes.Requireable<boolean>;
+        activateSingleItem: PropTypes.Requireable<boolean>;
+        activateFirstItem: PropTypes.Requireable<boolean>;
+        shortcuts: PropTypes.Requireable<boolean>;
+        onMouseOut: PropTypes.Requireable<(...args: any[]) => any>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        onScrollToBottom: PropTypes.Requireable<(...args: any[]) => any>;
+        onResize: PropTypes.Requireable<(...args: any[]) => any>;
+        useMouseUp: PropTypes.Requireable<boolean>;
+        visible: PropTypes.Requireable<boolean>;
+        renderOptimization: PropTypes.Requireable<boolean>;
+        disableMoveOverflow: PropTypes.Requireable<boolean>;
+        disableMoveDownOverflow: PropTypes.Requireable<boolean>;
+        compact: PropTypes.Requireable<boolean>;
+        disableScrollToActive: PropTypes.Requireable<boolean>;
+        hidden: PropTypes.Requireable<boolean>;
+        ariaLabel: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        data: never[];
+        restoreActiveIndex: boolean;
+        activateSingleItem: boolean;
+        activateFirstItem: boolean;
+        onMouseOut: typeof noop;
+        onSelect: typeof noop;
+        onScrollToBottom: typeof noop;
+        onResize: typeof noop;
+        shortcuts: boolean;
+        renderOptimization: boolean;
+        disableMoveDownOverflow: boolean;
+        ariaLabel: string;
+    };
+    state: ListState<T>;
+    static getDerivedStateFromProps(nextProps: ListProps, prevState: ListState): {
+        prevActiveIndex: number | null | undefined;
+        prevData: readonly ListDataItem<unknown>[];
+    };
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: ListProps<T>, nextState: ListState<T>): boolean;
+    componentDidUpdate(prevProps: ListProps<T>): void;
+    componentWillUnmount(): void;
+    static isItemType: typeof isItemType;
+    static ListHint: typeof ListHint;
+    static ListProps: {
+        Type: typeof Type;
+        Dimension: typeof Dimension;
+    };
+    virtualizedList?: VirtualizedList | null;
+    unmounted?: boolean;
+    container?: HTMLElement | null;
+    hoverHandler: (arg: number) => () => void;
+    private _activatableItems;
+    private _bufferSize;
+    sizeCacheKey: (index: number) => string | Type.ITEM | Type.MARGIN;
+    private _cache;
+    private _hasActivatableItems;
+    hasActivatableItems(): any;
+    selectHandler: (arg: number) => (event: Event | SyntheticEvent, tryKeepOpen?: boolean) => void;
+    checkboxHandler: (arg: number) => (event: SyntheticEvent) => void;
+    upHandler: (e: KeyboardEvent) => void;
+    downHandler: (e: KeyboardEvent) => void;
+    homeHandler: (e: KeyboardEvent) => void;
+    endHandler: (e: KeyboardEvent) => void;
+    onDocumentMouseMove: () => void;
+    onDocumentKeyDown: (e: KeyboardEvent) => void;
+    moveHandler(index: number, retryCallback: (e: KeyboardEvent) => void, e: KeyboardEvent): void;
+    mouseHandler: () => void;
+    scrollHandler: () => void;
+    enterHandler: (event: KeyboardEvent, shortcut?: string | undefined) => boolean;
+    getFirst(): ListDataItem<T> | undefined;
+    getSelected(): ListDataItem<T> | null;
+    clearSelected: () => void;
+    defaultItemHeight(): Dimension.ITEM_HEIGHT | Dimension.COMPACT_ITEM_HEIGHT;
+    scrollEndHandler: () => void;
+    checkOverflow: () => void;
+    getVisibleListHeight(maxHeight: number): number;
+    private _deprecatedGenerateKeyFromContent;
+    getId(item: ListDataItem<T> | null): string | undefined;
+    renderItem: ({ index, style, isScrolling, parent, key }: Partial<ListRowProps>) => JSX.Element;
+    addItemDataTestToProp: (props: ListDataItemProps<T>) => ListDataItemProps<T>;
+    virtualizedListRef: (el: VirtualizedList | null) => void;
+    containerRef: (el: HTMLElement | null) => void;
+    private _inner?;
+    get inner(): HTMLElement | null | undefined;
+    renderVirtualizedInner({ height, maxHeight, autoHeight, rowCount, isScrolling, onChildScroll, scrollTop, registerChild }: RenderVirtualizedInnerParams): JSX.Element;
+    renderVirtualized(maxHeight: number | null | undefined, rowCount: number): JSX.Element;
+    renderSimple(maxHeight: number | null | undefined, rowCount: number): JSX.Element;
+    id: string;
+    shortcutsScope: string;
+    shortcutsMap: ShortcutsMap;
+    /** @override */
+    render(): JSX.Element;
+}
+export declare type ListAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof List, ListProps<T>>;
+export {};