@blueprintjs/core

  • Version 4.3.1
  • Published
  • 4.87 MB
  • 11 dependencies
  • Apache-2.0 license

Install

npm i @blueprintjs/core
yarn add @blueprintjs/core
pnpm add @blueprintjs/core

Overview

Core styles & components

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable Alignment

const Alignment: { CENTER: 'center'; LEFT: 'left'; RIGHT: 'right' };
  • Alignment along the horizontal axis.

variable Blockquote

const Blockquote: React.FC<any>;

    variable Boundary

    const Boundary: { START: 'start'; END: 'end' };
    • Boundary of a one-dimensional interval.

    const Breadcrumb: React.FC<IBreadcrumbProps>;

      variable Code

      const Code: React.FC<any>;

        variable ContextMenu

        const ContextMenu: typeof contextMenu;

          variable DISPLAYNAME_PREFIX

          const DISPLAYNAME_PREFIX: string;

            variable Elevation

            const Elevation: { ZERO: 0; ONE: 1; TWO: 2; THREE: 3; FOUR: 4 };

              variable Expander

              const Expander: React.FC;

                variable FocusStyleManager

                const FocusStyleManager: {
                alwaysShowFocus: () => boolean | void;
                isActive: () => boolean;
                onlyShowFocusOnTabs: () => boolean | void;
                };

                  variable H1

                  const H1: React.FC<any>;

                    variable H2

                    const H2: React.FC<any>;

                      variable H3

                      const H3: React.FC<any>;

                        variable H4

                        const H4: React.FC<any>;

                          variable H5

                          const H5: React.FC<any>;

                            variable H6

                            const H6: React.FC<any>;

                              variable HandleInteractionKind

                              const HandleInteractionKind: { LOCK: 'lock'; PUSH: 'push'; NONE: 'none' };

                                variable HandleType

                                const HandleType: { FULL: 'full'; START: 'start'; END: 'end' };

                                  variable HotkeysContext

                                  const HotkeysContext: React.Context<HotkeysContextInstance>;
                                  • A React context used to register and deregister hotkeys as components are mounted and unmounted in an application. Users should take care to make sure that only _one_ of these is instantiated and used within an application, especially if using global hotkeys.

                                    You will likely not be using this HotkeysContext directly, except in cases where you need to get a direct handle on an existing context instance for advanced use cases involving nested HotkeysProviders.

                                    For more information, see the [HotkeysProvider documentation](https://blueprintjs.com/docs/#core/context/hotkeys-provider).

                                  variable HotkeysDialog2

                                  const HotkeysDialog2: React.FC<HotkeysDialog2Props>;

                                    variable Intent

                                    const Intent: {
                                    NONE: 'none';
                                    PRIMARY: 'primary';
                                    SUCCESS: 'success';
                                    WARNING: 'warning';
                                    DANGER: 'danger';
                                    };
                                    • The four basic intents.

                                    variable Label

                                    const Label: React.FC<any>;

                                      variable OL

                                      const OL: React.FC<any>;

                                        variable OverlayToaster

                                        const OverlayToaster: typeof Toaster;

                                          variable PanelStack2

                                          const PanelStack2: PanelStack2Component;
                                          • T type union of all possible panels in this stack

                                          variable PopoverInteractionKind

                                          const PopoverInteractionKind: {
                                          CLICK: 'click';
                                          CLICK_TARGET_ONLY: 'click-target';
                                          HOVER: 'hover';
                                          HOVER_TARGET_ONLY: 'hover-target';
                                          };

                                            variable PopoverPosition

                                            const PopoverPosition: {
                                            AUTO: 'auto';
                                            AUTO_END: 'auto-end';
                                            AUTO_START: 'auto-start';
                                            BOTTOM: 'bottom';
                                            BOTTOM_LEFT: 'bottom-left';
                                            BOTTOM_RIGHT: 'bottom-right';
                                            LEFT: 'left';
                                            LEFT_BOTTOM: 'left-bottom';
                                            LEFT_TOP: 'left-top';
                                            RIGHT: 'right';
                                            RIGHT_BOTTOM: 'right-bottom';
                                            RIGHT_TOP: 'right-top';
                                            TOP: 'top';
                                            TOP_LEFT: 'top-left';
                                            TOP_RIGHT: 'top-right';
                                            };
                                            • Position with "auto" values, used by Popover and Tooltip.

                                            variable Position

                                            const Position: {
                                            BOTTOM: 'bottom';
                                            BOTTOM_LEFT: 'bottom-left';
                                            BOTTOM_RIGHT: 'bottom-right';
                                            LEFT: 'left';
                                            LEFT_BOTTOM: 'left-bottom';
                                            LEFT_TOP: 'left-top';
                                            RIGHT: 'right';
                                            RIGHT_BOTTOM: 'right-bottom';
                                            RIGHT_TOP: 'right-top';
                                            TOP: 'top';
                                            TOP_LEFT: 'top-left';
                                            TOP_RIGHT: 'top-right';
                                            };

                                              variable Pre

                                              const Pre: React.FC<any>;

                                                variable UL

                                                const UL: React.FC<any>;

                                                  Functions

                                                  function combineRefs

                                                  combineRefs: <T extends HTMLElement>(
                                                  ref1: IRefCallback<T>,
                                                  ref2: IRefCallback<T>
                                                  ) => IRefCallback<T>;
                                                  • Deprecated

                                                    use mergeRefs() instead

                                                  function comboMatches

                                                  comboMatches: (a: IKeyCombo, b: IKeyCombo) => boolean;

                                                    function ContextMenuTarget

                                                    ContextMenuTarget: <T extends IConstructor<IContextMenuTargetComponent>>(
                                                    WrappedComponent: T
                                                    ) => {
                                                    new (...args: any[]): {
                                                    render():
                                                    | React.ReactElement<any, string | React.JSXElementConstructor<any>>
                                                    | null
                                                    | undefined;
                                                    renderContextMenu: (
                                                    e: React.MouseEvent<HTMLElement, MouseEvent>
                                                    ) => JSX.Element | undefined;
                                                    onContextMenuClose?: (() => void) | undefined;
                                                    context: any;
                                                    setState<K extends never>(
                                                    state:
                                                    | {}
                                                    | ((
                                                    prevState: Readonly<{}>,
                                                    props: Readonly<{}>
                                                    ) => {} | Pick<{}, K>)
                                                    | Pick<{}, K>,
                                                    callback?: (() => void) | undefined
                                                    ): void;
                                                    forceUpdate(callback?: (() => void) | undefined): void;
                                                    readonly props: Readonly<{}> & Readonly<{ children?: React.ReactNode }>;
                                                    state: Readonly<{}>;
                                                    refs: { [key: string]: React.ReactInstance };
                                                    componentDidMount?(): void;
                                                    shouldComponentUpdate?(
                                                    nextProps: Readonly<{}>,
                                                    nextState: Readonly<{}>,
                                                    nextContext: any
                                                    ): boolean;
                                                    componentWillUnmount?(): void;
                                                    componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
                                                    getSnapshotBeforeUpdate?(
                                                    prevProps: Readonly<{}>,
                                                    prevState: Readonly<{}>
                                                    ): any;
                                                    componentDidUpdate?(
                                                    prevProps: Readonly<{}>,
                                                    prevState: Readonly<{}>,
                                                    snapshot?: any
                                                    ): void;
                                                    componentWillMount?(): void;
                                                    UNSAFE_componentWillMount?(): void;
                                                    componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
                                                    UNSAFE_componentWillReceiveProps?(
                                                    nextProps: Readonly<{}>,
                                                    nextContext: any
                                                    ): void;
                                                    componentWillUpdate?(
                                                    nextProps: Readonly<{}>,
                                                    nextState: Readonly<{}>,
                                                    nextContext: any
                                                    ): void;
                                                    UNSAFE_componentWillUpdate?(
                                                    nextProps: Readonly<{}>,
                                                    nextState: Readonly<{}>,
                                                    nextContext: any
                                                    ): void;
                                                    };
                                                    displayName: string;
                                                    } & T;
                                                    • Deprecated

                                                      use ContextMenu2

                                                    function getKeyCombo

                                                    getKeyCombo: (e: KeyboardEvent) => IKeyCombo;
                                                    • Determines the key combo object from the given keyboard event. Again, a key combo includes zero or more modifiers (represented by a bitmask) and one action key, which we determine from the e.which property of the keyboard event.

                                                    function getKeyComboString

                                                    getKeyComboString: (e: KeyboardEvent) => string;
                                                    • Converts a keyboard event into a valid combo prop string

                                                    function getPositionIgnoreAngles

                                                    getPositionIgnoreAngles: (
                                                    position: Position
                                                    ) => 'left' | 'top' | 'bottom' | 'right';

                                                      function getRef

                                                      getRef: <T extends HTMLElement>(ref: T | IRefObject<T> | null) => T | null;

                                                        function hideHotkeysDialog

                                                        hideHotkeysDialog: () => void;

                                                          function HotkeysProvider

                                                          HotkeysProvider: ({
                                                          children,
                                                          dialogProps,
                                                          renderDialog,
                                                          value,
                                                          }: HotkeysProviderProps) => JSX.Element;
                                                          • Hotkeys context provider, necessary for the useHotkeys hook.

                                                          function HotkeysTarget

                                                          HotkeysTarget: <T extends IConstructor<IHotkeysTargetComponent>>(
                                                          WrappedComponent: T
                                                          ) => {
                                                          new (...args: any[]): {
                                                          globalHotkeysEvents: HotkeysEvents;
                                                          localHotkeysEvents: HotkeysEvents;
                                                          componentDidMount(): void;
                                                          componentWillUnmount(): void;
                                                          render(): JSX.Element;
                                                          renderHotkeys: () => React.ReactElement<
                                                          IHotkeysProps,
                                                          string | React.JSXElementConstructor<any>
                                                          >;
                                                          context: any;
                                                          setState<K extends never>(
                                                          state:
                                                          | {}
                                                          | ((
                                                          prevState: Readonly<{}>,
                                                          props: Readonly<{}>
                                                          ) => {} | Pick<{}, K>)
                                                          | Pick<{}, K>,
                                                          callback?: (() => void) | undefined
                                                          ): void;
                                                          forceUpdate(callback?: (() => void) | undefined): void;
                                                          readonly props: Readonly<{}> & Readonly<{ children?: React.ReactNode }>;
                                                          state: Readonly<{}>;
                                                          refs: { [key: string]: React.ReactInstance };
                                                          shouldComponentUpdate?(
                                                          nextProps: Readonly<{}>,
                                                          nextState: Readonly<{}>,
                                                          nextContext: any
                                                          ): boolean;
                                                          componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
                                                          getSnapshotBeforeUpdate?(
                                                          prevProps: Readonly<{}>,
                                                          prevState: Readonly<{}>
                                                          ): any;
                                                          componentDidUpdate?(
                                                          prevProps: Readonly<{}>,
                                                          prevState: Readonly<{}>,
                                                          snapshot?: any
                                                          ): void;
                                                          componentWillMount?(): void;
                                                          UNSAFE_componentWillMount?(): void;
                                                          componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
                                                          UNSAFE_componentWillReceiveProps?(
                                                          nextProps: Readonly<{}>,
                                                          nextContext: any
                                                          ): void;
                                                          componentWillUpdate?(
                                                          nextProps: Readonly<{}>,
                                                          nextState: Readonly<{}>,
                                                          nextContext: any
                                                          ): void;
                                                          UNSAFE_componentWillUpdate?(
                                                          nextProps: Readonly<{}>,
                                                          nextState: Readonly<{}>,
                                                          nextContext: any
                                                          ): void;
                                                          };
                                                          displayName: string;
                                                          } & T;
                                                          • Deprecated

                                                            use useHotkeys hook or <HotkeysTarget2> component

                                                          function HotkeysTarget2

                                                          HotkeysTarget2: ({
                                                          children,
                                                          hotkeys,
                                                          options,
                                                          }: HotkeysTarget2Props) => JSX.Element;
                                                          • Utility component which allows consumers to use the new useHotkeys hook inside React component classes. The implementation simply passes through to the hook.

                                                          function isPositionHorizontal

                                                          isPositionHorizontal: (position: Position) => boolean;

                                                            function isPositionVertical

                                                            isPositionVertical: (position: Position) => boolean;

                                                              function isRefCallback

                                                              isRefCallback: <T extends HTMLElement>(
                                                              value: IRef<T> | undefined | null
                                                              ) => value is IRefCallback<T>;

                                                                function isRefObject

                                                                isRefObject: <T extends HTMLElement>(
                                                                value: IRef<T> | undefined | null
                                                                ) => value is IRefObject<T>;

                                                                  function mergeRefs

                                                                  mergeRefs: <T extends HTMLElement>(
                                                                  ...refs: Array<IRef<T> | null>
                                                                  ) => IRefCallback<T>;
                                                                  • Utility for merging refs into one singular callback ref. If using in a functional component, would recomend using useMemo to preserve function identity.

                                                                  function parseKeyCombo

                                                                  parseKeyCombo: (combo: string) => IKeyCombo;
                                                                  • Converts a key combo string into a key combo object. Key combos include zero or more modifier keys, such as shift or alt, and exactly one action key, such as A, enter, or left.

                                                                    For action keys that require a shift, e.g. @ or |, we inlude the necessary shift modifier and automatically convert the action key to the unshifted version. For example, @ is equivalent to shift+2.

                                                                  function refHandler

                                                                  refHandler: <T extends HTMLElement, K extends string>(
                                                                  refTargetParent: { [k in K]: T },
                                                                  refTargetKey: K,
                                                                  refProp?: IRef<T> | undefined | null
                                                                  ) => IRefCallback<T>;
                                                                  • Creates a ref handler which assigns the ref returned by React for a mounted component to a field on the target object. The target object is usually a component class.

                                                                    If provided, it will also update the given refProp with the value of the ref.

                                                                  function removeNonHTMLProps

                                                                  removeNonHTMLProps: (
                                                                  props: { [key: string]: any },
                                                                  invalidProps?: string[],
                                                                  shouldMerge?: boolean
                                                                  ) => { [key: string]: any };
                                                                  • Typically applied to HTMLElements to filter out disallowed props. When applied to a Component, can filter props from being passed down to the children. Can also filter by a combined list of supplied prop keys and the denylist (only appropriate for HTMLElements).

                                                                    Parameter props

                                                                    The original props object to filter down.

                                                                    Parameter invalidProps

                                                                    If supplied, overwrites the default denylist.

                                                                    Parameter shouldMerge

                                                                    If true, will merge supplied invalidProps and denylist together.

                                                                  function setHotkeysDialogProps

                                                                  setHotkeysDialogProps: (props: Partial<IHotkeysDialogProps>) => void;

                                                                    function setRef

                                                                    setRef: <T extends HTMLElement>(
                                                                    refTarget: IRef<T> | undefined | null,
                                                                    ref: T | null
                                                                    ) => void;
                                                                    • Assign the given ref to a target, either a React ref object or a callback which takes the ref as its first argument.

                                                                    function useHotkeys

                                                                    useHotkeys: (
                                                                    keys: readonly HotkeyConfig[],
                                                                    options?: UseHotkeysOptions
                                                                    ) => UseHotkeysReturnValue;
                                                                    • React hook to register global and local hotkeys for a component.

                                                                      Parameter keys

                                                                      list of hotkeys to configure

                                                                      Parameter options

                                                                      hook options

                                                                    Classes

                                                                    class AbstractComponent

                                                                    abstract class AbstractComponent<P, S> extends React.Component<P, S> {}
                                                                    • An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.

                                                                      Deprecated

                                                                      componentWillReceiveProps is deprecated in React 16.9; use AbstractComponent2 instead

                                                                    constructor

                                                                    constructor(props: {}, context?: any);

                                                                      property clearTimeouts

                                                                      clearTimeouts: () => void;
                                                                      • Clear all known timeouts.

                                                                      property displayName

                                                                      protected displayName: never;
                                                                      • Component displayName should be public static. This property exists to prevent incorrect usage.

                                                                      method componentWillReceiveProps

                                                                      componentWillReceiveProps: (
                                                                      nextProps: P & { children?: React.ReactNode }
                                                                      ) => void;

                                                                        method componentWillUnmount

                                                                        componentWillUnmount: () => void;

                                                                          method setTimeout

                                                                          setTimeout: (callback: () => void, timeout?: number) => () => void;
                                                                          • Set a timeout and remember its ID. All stored timeouts will be cleared when component unmounts.

                                                                            Returns

                                                                            a "cancel" function that will clear timeout when invoked.

                                                                          method validateProps

                                                                          protected validateProps: (_: P & { children?: React.ReactNode }) => void;
                                                                          • Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.

                                                                            This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

                                                                          class AbstractComponent2

                                                                          abstract class AbstractComponent2<P, S = {}, SS = {}> extends React.Component<
                                                                          P,
                                                                          S,
                                                                          SS
                                                                          > {}
                                                                          • An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.

                                                                          constructor

                                                                          constructor(props: {}, context?: any);

                                                                            property cancelAnimationFrames

                                                                            cancelAnimationFrames: () => void;
                                                                            • Clear all known animation frame requests.

                                                                            property clearTimeouts

                                                                            clearTimeouts: () => void;
                                                                            • Clear all known timeouts.

                                                                            property componentWillMount

                                                                            componentWillMount: never;

                                                                              property componentWillReceiveProps

                                                                              componentWillReceiveProps: never;

                                                                                property componentWillUpdate

                                                                                componentWillUpdate: never;

                                                                                  property displayName

                                                                                  protected displayName: never;
                                                                                  • Component displayName should be public static. This property exists to prevent incorrect usage.

                                                                                  property getDerivedStateFromProps

                                                                                  getDerivedStateFromProps: never;

                                                                                    method componentDidUpdate

                                                                                    componentDidUpdate: (_prevProps: P, _prevState: S, _snapshot?: SS) => void;

                                                                                      method componentWillUnmount

                                                                                      componentWillUnmount: () => void;

                                                                                        method requestAnimationFrame

                                                                                        requestAnimationFrame: (callback: () => void) => () => void;
                                                                                        • Request an animation frame and remember its ID. All pending requests will be canceled when component unmounts.

                                                                                          Returns

                                                                                          a "cancel" function that will cancel the request when invoked.

                                                                                        method setTimeout

                                                                                        setTimeout: (callback: () => void, timeout?: number) => () => void;
                                                                                        • Set a timeout and remember its ID. All stored timeouts will be cleared when component unmounts.

                                                                                          Returns

                                                                                          a "cancel" function that will clear timeout when invoked.

                                                                                        method validateProps

                                                                                        protected validateProps: (_props: P) => void;
                                                                                        • Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.

                                                                                          This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

                                                                                        class AbstractPureComponent

                                                                                        abstract class AbstractPureComponent<P, S = {}> extends React.PureComponent<P, S> {}
                                                                                        • An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.

                                                                                          Deprecated

                                                                                          componentWillReceiveProps is deprecated in React 16.9; use AbstractPureComponent2 instead

                                                                                        constructor

                                                                                        constructor(props: {}, context?: any);

                                                                                          property clearTimeouts

                                                                                          clearTimeouts: () => void;
                                                                                          • Clear all known timeouts.

                                                                                          property displayName

                                                                                          protected displayName: never;
                                                                                          • Component displayName should be public static. This property exists to prevent incorrect usage.

                                                                                          method componentWillReceiveProps

                                                                                          componentWillReceiveProps: (
                                                                                          nextProps: P & { children?: React.ReactNode }
                                                                                          ) => void;

                                                                                            method componentWillUnmount

                                                                                            componentWillUnmount: () => void;

                                                                                              method setTimeout

                                                                                              setTimeout: (callback: () => void, timeout?: number) => () => void;
                                                                                              • Set a timeout and remember its ID. All stored timeouts will be cleared when component unmounts.

                                                                                                Returns

                                                                                                a "cancel" function that will clear timeout when invoked.

                                                                                              method validateProps

                                                                                              protected validateProps: (_props: P & { children?: React.ReactNode }) => void;
                                                                                              • Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.

                                                                                                This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

                                                                                              class AbstractPureComponent2

                                                                                              abstract class AbstractPureComponent2<
                                                                                              P,
                                                                                              S = {},
                                                                                              SS = {}
                                                                                              > extends React.PureComponent<P, S, SS> {}
                                                                                              • An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.

                                                                                              constructor

                                                                                              constructor(props: {}, context?: any);

                                                                                                property cancelAnimationFrames

                                                                                                cancelAnimationFrames: () => void;
                                                                                                • Clear all known animation frame requests.

                                                                                                property clearTimeouts

                                                                                                clearTimeouts: () => void;
                                                                                                • Clear all known timeouts.

                                                                                                property componentWillMount

                                                                                                componentWillMount: never;

                                                                                                  property componentWillReceiveProps

                                                                                                  componentWillReceiveProps: never;

                                                                                                    property componentWillUpdate

                                                                                                    componentWillUpdate: never;

                                                                                                      property displayName

                                                                                                      protected displayName: never;
                                                                                                      • Component displayName should be public static. This property exists to prevent incorrect usage.

                                                                                                      property getDerivedStateFromProps

                                                                                                      getDerivedStateFromProps: never;

                                                                                                        method componentDidUpdate

                                                                                                        componentDidUpdate: (_prevProps: P, _prevState: S, _snapshot?: SS) => void;

                                                                                                          method componentWillUnmount

                                                                                                          componentWillUnmount: () => void;

                                                                                                            method requestAnimationFrame

                                                                                                            requestAnimationFrame: (callback: () => void) => () => void;
                                                                                                            • Request an animation frame and remember its ID. All pending requests will be canceled when component unmounts.

                                                                                                              Returns

                                                                                                              a "cancel" function that will cancel the request when invoked.

                                                                                                            method setTimeout

                                                                                                            setTimeout: (callback: () => void, timeout?: number) => () => void;
                                                                                                            • Set a timeout and remember its ID. All pending timeouts will be cleared when component unmounts.

                                                                                                              Returns

                                                                                                              a "cancel" function that will clear timeout when invoked.

                                                                                                            method validateProps

                                                                                                            protected validateProps: (_props: P) => void;
                                                                                                            • Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.

                                                                                                              This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

                                                                                                            class Alert

                                                                                                            class Alert extends AbstractPureComponent2<AlertProps> {}

                                                                                                              property defaultProps

                                                                                                              static defaultProps: IAlertProps;

                                                                                                                property displayName

                                                                                                                static displayName: string;

                                                                                                                  method render

                                                                                                                  render: () => JSX.Element;

                                                                                                                    method validateProps

                                                                                                                    protected validateProps: (props: AlertProps) => void;

                                                                                                                      class AnchorButton

                                                                                                                      class AnchorButton extends AbstractButton<HTMLAnchorElement> {}

                                                                                                                        property buttonRef

                                                                                                                        buttonRef: HTMLAnchorElement;

                                                                                                                          property displayName

                                                                                                                          static displayName: string;

                                                                                                                            property handleRef

                                                                                                                            protected handleRef: IRef<HTMLAnchorElement>;

                                                                                                                              method componentDidUpdate

                                                                                                                              componentDidUpdate: (prevProps: AnchorButtonProps) => void;

                                                                                                                                method render

                                                                                                                                render: () => JSX.Element;
                                                                                                                                  class Breadcrumbs extends AbstractPureComponent2<BreadcrumbsProps> {}
                                                                                                                                    static defaultProps: Partial<IBreadcrumbsProps>;
                                                                                                                                      render: () => JSX.Element;

                                                                                                                                        class Button

                                                                                                                                        class Button extends AbstractButton<HTMLButtonElement> {}

                                                                                                                                          property buttonRef

                                                                                                                                          buttonRef: HTMLButtonElement;

                                                                                                                                            property displayName

                                                                                                                                            static displayName: string;

                                                                                                                                              property handleRef

                                                                                                                                              protected handleRef: IRef<HTMLButtonElement>;

                                                                                                                                                method componentDidUpdate

                                                                                                                                                componentDidUpdate: (prevProps: ButtonProps) => void;

                                                                                                                                                  method render

                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                    class ButtonGroup

                                                                                                                                                    class ButtonGroup extends AbstractPureComponent2<ButtonGroupProps> {}

                                                                                                                                                      property displayName

                                                                                                                                                      static displayName: string;

                                                                                                                                                        method render

                                                                                                                                                        render: () => JSX.Element;

                                                                                                                                                          class Callout

                                                                                                                                                          class Callout extends AbstractPureComponent2<CalloutProps> {}

                                                                                                                                                            property displayName

                                                                                                                                                            static displayName: string;

                                                                                                                                                              method render

                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                class Card

                                                                                                                                                                class Card extends AbstractPureComponent2<CardProps> {}

                                                                                                                                                                  property defaultProps

                                                                                                                                                                  static defaultProps: ICardProps;

                                                                                                                                                                    property displayName

                                                                                                                                                                    static displayName: string;

                                                                                                                                                                      method render

                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                        class Checkbox

                                                                                                                                                                        class Checkbox extends AbstractPureComponent2<CheckboxProps, ICheckboxState> {}

                                                                                                                                                                          property displayName

                                                                                                                                                                          static displayName: string;

                                                                                                                                                                            property input

                                                                                                                                                                            input: HTMLInputElement;

                                                                                                                                                                              property state

                                                                                                                                                                              state: ICheckboxState;

                                                                                                                                                                                method componentDidMount

                                                                                                                                                                                componentDidMount: () => void;

                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                  componentDidUpdate: (prevProps: CheckboxProps) => void;

                                                                                                                                                                                    method getDerivedStateFromProps

                                                                                                                                                                                    static getDerivedStateFromProps: ({
                                                                                                                                                                                    indeterminate,
                                                                                                                                                                                    }: CheckboxProps) => ICheckboxState | null;

                                                                                                                                                                                      method render

                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                        class Collapse

                                                                                                                                                                                        class Collapse extends AbstractPureComponent2<CollapseProps, ICollapseState> {}

                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                          static defaultProps: Partial<ICollapseProps>;

                                                                                                                                                                                            property displayName

                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                              property state

                                                                                                                                                                                              state: ICollapseState;

                                                                                                                                                                                                method componentDidMount

                                                                                                                                                                                                componentDidMount: () => void;

                                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                                  componentDidUpdate: () => void;

                                                                                                                                                                                                    method getDerivedStateFromProps

                                                                                                                                                                                                    static getDerivedStateFromProps: (
                                                                                                                                                                                                    props: CollapseProps,
                                                                                                                                                                                                    state: ICollapseState
                                                                                                                                                                                                    ) =>
                                                                                                                                                                                                    | { animationState: AnimationStates; height?: undefined }
                                                                                                                                                                                                    | { animationState: AnimationStates; height: string }
                                                                                                                                                                                                    | null;

                                                                                                                                                                                                      method render

                                                                                                                                                                                                      render: () => React.ReactElement<any, any>;

                                                                                                                                                                                                        class CollapsibleList

                                                                                                                                                                                                        class CollapsibleList extends React.Component<CollapsibleListProps> {}
                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                          use <OverflowList> for automatic overflow based on available space.

                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                        static defaultProps: Partial<ICollapsibleListProps>;

                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                            method render

                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                              class ControlGroup

                                                                                                                                                                                                              class ControlGroup extends AbstractPureComponent2<ControlGroupProps> {}

                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                                                                                    class Dialog

                                                                                                                                                                                                                    class Dialog extends AbstractPureComponent2<DialogProps> {}

                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                      constructor(props: IDialogProps);

                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                        static defaultProps: IDialogProps;

                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                              method validateProps

                                                                                                                                                                                                                              protected validateProps: (props: DialogProps) => void;

                                                                                                                                                                                                                                class DialogStep

                                                                                                                                                                                                                                class DialogStep extends AbstractPureComponent2<DialogStepProps> {}

                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                                                      class Divider

                                                                                                                                                                                                                                      class Divider extends AbstractPureComponent2<IDividerProps> {}

                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                          render: () => JSX.Element;

                                                                                                                                                                                                                                            class Drawer

                                                                                                                                                                                                                                            class Drawer extends AbstractPureComponent2<DrawerProps> {}

                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                              static defaultProps: IDrawerProps;

                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                                                                                                                    method validateProps

                                                                                                                                                                                                                                                    protected validateProps: (props: DrawerProps) => void;

                                                                                                                                                                                                                                                      class EditableText

                                                                                                                                                                                                                                                      class EditableText extends AbstractPureComponent2<
                                                                                                                                                                                                                                                      EditableTextProps,
                                                                                                                                                                                                                                                      IEditableTextState
                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                        constructor(props: IEditableTextProps, context?: any);

                                                                                                                                                                                                                                                          property cancelEditing

                                                                                                                                                                                                                                                          cancelEditing: () => void;

                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                            static defaultProps: IEditableTextProps;

                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                property toggleEditing

                                                                                                                                                                                                                                                                toggleEditing: () => void;

                                                                                                                                                                                                                                                                  method componentDidMount

                                                                                                                                                                                                                                                                  componentDidMount: () => void;

                                                                                                                                                                                                                                                                    method componentDidUpdate

                                                                                                                                                                                                                                                                    componentDidUpdate: (
                                                                                                                                                                                                                                                                    prevProps: EditableTextProps,
                                                                                                                                                                                                                                                                    prevState: IEditableTextState
                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                                                                                                        class FileInput

                                                                                                                                                                                                                                                                        class FileInput extends AbstractPureComponent2<FileInputProps> {}

                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                          static defaultProps: IFileInputProps;

                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                class FormGroup

                                                                                                                                                                                                                                                                                class FormGroup extends AbstractPureComponent2<FormGroupProps> {}

                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                                                                                                      class Hotkey

                                                                                                                                                                                                                                                                                      class Hotkey extends AbstractPureComponent2<IHotkeyProps> {}

                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                                                        allowInInput: boolean;
                                                                                                                                                                                                                                                                                        disabled: boolean;
                                                                                                                                                                                                                                                                                        global: boolean;
                                                                                                                                                                                                                                                                                        preventDefault: boolean;
                                                                                                                                                                                                                                                                                        stopPropagation: boolean;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                                                                                              method validateProps

                                                                                                                                                                                                                                                                                              protected validateProps: (props: IHotkeyProps) => void;

                                                                                                                                                                                                                                                                                                class Hotkeys

                                                                                                                                                                                                                                                                                                class Hotkeys extends AbstractPureComponent2<IHotkeysProps> {}

                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                  static defaultProps: { tabIndex: number };

                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                      render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                        method validateProps

                                                                                                                                                                                                                                                                                                        protected validateProps: (
                                                                                                                                                                                                                                                                                                        props: IHotkeysProps & { children: React.ReactNode }
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          class HTMLSelect

                                                                                                                                                                                                                                                                                                          class HTMLSelect extends AbstractPureComponent2<HTMLSelectProps> {}

                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                              class HTMLTable

                                                                                                                                                                                                                                                                                                              class HTMLTable extends AbstractPureComponent2<HTMLTableProps> {}

                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                  class Icon

                                                                                                                                                                                                                                                                                                                  class Icon extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                  IconProps & Omit<React.HTMLAttributes<HTMLElement>, 'title'>
                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                        class InputGroup

                                                                                                                                                                                                                                                                                                                        class InputGroup extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                        InputGroupProps2,
                                                                                                                                                                                                                                                                                                                        IInputGroupState
                                                                                                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                                                                                                                            state: IInputGroupState;

                                                                                                                                                                                                                                                                                                                              method componentDidMount

                                                                                                                                                                                                                                                                                                                              componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                componentDidUpdate: (prevProps: InputGroupProps2) => void;

                                                                                                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                    method validateProps

                                                                                                                                                                                                                                                                                                                                    protected validateProps: (props: InputGroupProps2) => void;

                                                                                                                                                                                                                                                                                                                                      class KeyCombo

                                                                                                                                                                                                                                                                                                                                      class KeyCombo extends AbstractPureComponent2<KeyComboTagProps> {}

                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                          render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                            class Menu extends AbstractPureComponent2<MenuProps> {}
                                                                                                                                                                                                                                                                                                                                              static displayName: string;
                                                                                                                                                                                                                                                                                                                                                render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                                  class MenuDivider extends React.Component<MenuDividerProps> {}
                                                                                                                                                                                                                                                                                                                                                    static displayName: string;
                                                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                                        class MenuItem extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                                        MenuItemProps & React.AnchorHTMLAttributes<HTMLAnchorElement>
                                                                                                                                                                                                                                                                                                                                                        > {}
                                                                                                                                                                                                                                                                                                                                                          static defaultProps: IMenuItemProps;
                                                                                                                                                                                                                                                                                                                                                            static displayName: string;
                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                class MultiSlider

                                                                                                                                                                                                                                                                                                                                                                class MultiSlider extends AbstractPureComponent2<MultiSliderProps, ISliderState> {}

                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: IMultiSliderProps;

                                                                                                                                                                                                                                                                                                                                                                    property defaultSliderProps

                                                                                                                                                                                                                                                                                                                                                                    static defaultSliderProps: ISliderBaseProps;

                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                        property Handle

                                                                                                                                                                                                                                                                                                                                                                        static Handle: React.FC<IHandleProps>;

                                                                                                                                                                                                                                                                                                                                                                          property state

                                                                                                                                                                                                                                                                                                                                                                          state: ISliderState;

                                                                                                                                                                                                                                                                                                                                                                            method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                            componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                              method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                              componentDidUpdate: (
                                                                                                                                                                                                                                                                                                                                                                              prevProps: MultiSliderProps,
                                                                                                                                                                                                                                                                                                                                                                              prevState: ISliderState
                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                                                                                                static getDerivedStateFromProps: (props: MultiSliderProps) => {
                                                                                                                                                                                                                                                                                                                                                                                labelPrecision: number;
                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                  method getSnapshotBeforeUpdate

                                                                                                                                                                                                                                                                                                                                                                                  getSnapshotBeforeUpdate: (prevProps: MultiSliderProps) => null;

                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                      method validateProps

                                                                                                                                                                                                                                                                                                                                                                                      protected validateProps: (
                                                                                                                                                                                                                                                                                                                                                                                      props: React.PropsWithChildren<IMultiSliderProps>
                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                        class MultistepDialog

                                                                                                                                                                                                                                                                                                                                                                                        class MultistepDialog extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                                                                        MultistepDialogProps,
                                                                                                                                                                                                                                                                                                                                                                                        IMultistepDialogState
                                                                                                                                                                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                          static defaultProps: Partial<IMultistepDialogProps>;

                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                              property state

                                                                                                                                                                                                                                                                                                                                                                                              state: IMultistepDialogState;

                                                                                                                                                                                                                                                                                                                                                                                                method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                componentDidUpdate: (prevProps: MultistepDialogProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                                                                                                                                                                  render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                                                                                    class Navbar extends AbstractPureComponent2<NavbarProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                        static Divider: typeof NavbarDivider;
                                                                                                                                                                                                                                                                                                                                                                                                          static Group: typeof NavbarGroup;
                                                                                                                                                                                                                                                                                                                                                                                                            static Heading: typeof NavbarHeading;
                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                                                                                                class NavbarDivider extends AbstractPureComponent2<NavbarDividerProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                                                                                                      class NavbarGroup extends AbstractPureComponent2<NavbarGroupProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: INavbarGroupProps;
                                                                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                                                                                                              class NavbarHeading extends AbstractPureComponent2<NavbarHeadingProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                    class NonIdealState

                                                                                                                                                                                                                                                                                                                                                                                                                                    class NonIdealState extends AbstractPureComponent2<NonIdealStateProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                      static defaultProps: Partial<INonIdealStateProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                            class NumericInput

                                                                                                                                                                                                                                                                                                                                                                                                                                            class NumericInput extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                                                                                                                            HTMLInputProps & NumericInputProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                            INumericInputState
                                                                                                                                                                                                                                                                                                                                                                                                                                            > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                              static defaultProps: INumericInputProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property inputElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                  inputElement: HTMLInputElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                    state: INumericInputState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property VALUE_EMPTY

                                                                                                                                                                                                                                                                                                                                                                                                                                                      static VALUE_EMPTY: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property VALUE_ZERO

                                                                                                                                                                                                                                                                                                                                                                                                                                                        static VALUE_ZERO: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentDidUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          prevProps: NumericInputProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          prevState: INumericInputState
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                            static getDerivedStateFromProps: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            props: NumericInputProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: INumericInputState
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            stepMaxPrecision: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            prevMaxProp: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            prevMinProp: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected validateProps: (nextProps: HTMLInputProps & NumericInputProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class OverflowList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class OverflowList<T> extends React.Component<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OverflowListProps<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IOverflowListState<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static defaultProps: Partial<OverflowListProps<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        state: IOverflowListState<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            componentDidUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prevProps: OverflowListProps<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prevState: IOverflowListState<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static ofType: <U>() => new (props: OverflowListProps<U>) => OverflowList<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method shouldComponentUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shouldComponentUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _nextProps: OverflowListProps<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nextState: IOverflowListState<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Overlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Overlay extends AbstractPureComponent2<OverlayProps, IOverlayState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property containerElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      containerElement: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: IOverlayProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: IOverlayState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentDidUpdate: (prevProps: OverlayProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static getDerivedStateFromProps: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isOpen: hasEverOpened,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }: OverlayProps) => { hasEverOpened: true } | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PanelStack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PanelStack extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IPanelStackProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IPanelStackState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          use PanelStack2<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        state: IPanelStackState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentDidUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prevProps: IPanelStackProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prevState: IPanelStackState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected validateProps: (props: IPanelStackProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Popover

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Popover extends AbstractPureComponent2<IPopoverProps, IPopoverState> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  use { Popover2 } from "@blueprintjs/popover2"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static defaultProps: IPopoverProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property popoverElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    popoverElement: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • DOM element that contains the popover. When usePortal={true}, this element will be portaled outside the usual DOM flow, so this reference can be very useful for testing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property reposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reposition: () => void | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Instance method to instruct the Popover to recompute its position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This method should only be used if you are updating the target in a way that does not cause it to re-render, such as changing its _position_ without changing its _size_ (since Popover already repositions when it detects a resize).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    state: IPopoverState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property targetElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      targetElement: HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • DOM element that contains the target.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentDidUpdate: (prevProps: IPopoverProps, prevState: IPopoverState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected validateProps: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            props: IPopoverProps & { children?: React.ReactNode }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Portal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Portal extends React.Component<PortalProps, IPortalState> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • This component detaches its contents and re-attaches them to document.body. Use it when you need to circumvent DOM z-stacking (for dialogs, popovers, etc.). Any class names passed to this element will be propagated to the new container element on document.body.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context: IPortalContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property contextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static contextTypes: ValidationMap<IPortalContext>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: Partial<IPortalProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: IPortalState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentDidUpdate: (prevProps: PortalProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => React.ReactPortal | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProgressBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ProgressBar extends AbstractPureComponent2<ProgressBarProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Radio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Radio extends AbstractPureComponent2<RadioProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class RadioGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class RadioGroup extends AbstractPureComponent2<RadioGroupProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected validateProps: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RangeSlider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RangeSlider extends AbstractPureComponent2<RangeSliderProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static defaultProps: IRangeSliderProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected validateProps: (props: RangeSliderProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ResizeSensor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ResizeSensor extends AbstractPureComponent2<ResizeSensorProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • ResizeSensor requires a single DOM element child and will error otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentDidUpdate: (prevProps: ResizeSensorProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () =>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | React.ReactChild
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | React.ReactPortal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Slider extends AbstractPureComponent2<SliderProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static defaultProps: ISliderProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Spinner extends AbstractPureComponent2<SpinnerProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentDidUpdate: (prevProps: SpinnerProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => React.ReactElement<{ className: string; role: string }, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected validateProps: ({ className, size }: SpinnerProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Switch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Switch extends AbstractPureComponent2<SwitchProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Tab extends AbstractPureComponent2<TabProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: Partial<ITabProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Tabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Tabs extends AbstractPureComponent2<TabsProps, ITabsState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(props: ITabsProps);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static defaultProps: Partial<ITabsProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Expander

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static Expander: React.FC<{}>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Insert a Tabs.Expander between any two children to right-align all subsequent children.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static Tab: typeof Tab;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentDidUpdate: (prevProps: TabsProps, prevState: ITabsState) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static getDerivedStateFromProps: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selectedTabId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }: TabsProps) => { selectedTabId: TabId } | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Tag extends AbstractPureComponent2<TagProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TagInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TagInput extends AbstractPureComponent2<TagInputProps, ITagInputState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: Partial<ITagInputProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inputElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inputElement: HTMLInputElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        state: ITagInputState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentDidUpdate: (prevProps: TagInputProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static getDerivedStateFromProps: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            props: Readonly<TagInputProps>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: Readonly<ITagInputState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Partial<ITagInputState> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Text extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TextProps & Omit<React.HTMLAttributes<HTMLElement>, 'title'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ITextState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: Partial<ITextProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state: ITextState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentDidUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => React.DOMElement<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            className: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ref: (ref: HTMLElement | null) => HTMLElement | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            title: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            translate?: 'yes' | 'no' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hidden?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dir?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            slot?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            style?: React.CSSProperties | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accessKey?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            draggable?: (boolean | 'false' | 'true') | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lang?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefix?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contentEditable?: 'inherit' | (boolean | 'false' | 'true') | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inputMode?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'search'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'numeric'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'none'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'url'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'decimal'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'tel'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'email'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tabIndex?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            defaultChecked?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            defaultValue?: string | number | readonly string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            suppressContentEditableWarning?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            suppressHydrationWarning?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contextMenu?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            placeholder?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spellCheck?: (boolean | 'false' | 'true') | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            radioGroup?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            role?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            about?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            datatype?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inlist?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resource?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeof?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            vocab?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            autoCapitalize?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            autoCorrect?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            autoSave?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            itemProp?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            itemScope?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            itemType?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            itemID?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            itemRef?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            results?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            security?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unselectable?: 'on' | 'off' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            is?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-activedescendant'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-atomic'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-autocomplete'?: 'inline' | 'both' | 'none' | 'list' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-busy'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-checked'?: boolean | 'mixed' | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-colcount'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-colindex'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-colspan'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-controls'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-current'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'location'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'time'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'page'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'step'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'date'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-describedby'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-details'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-disabled'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-dropeffect'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'link'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'none'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'copy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'move'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'execute'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'popup'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-errormessage'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-expanded'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-flowto'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-grabbed'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-haspopup'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'grid'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'dialog'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'menu'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'listbox'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'tree'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-hidden'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-invalid'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'grammar'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'spelling'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-keyshortcuts'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-label'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-labelledby'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-level'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-live'?: 'off' | 'assertive' | 'polite' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-modal'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-multiline'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-multiselectable'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-orientation'?: 'horizontal' | 'vertical' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-owns'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-placeholder'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-posinset'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-pressed'?: boolean | 'mixed' | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-readonly'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-relevant'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'all'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'additions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'additions removals'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'additions text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'removals'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'removals additions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'removals text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'text additions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'text removals'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-required'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-roledescription'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-rowcount'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-rowindex'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-rowspan'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-selected'?: boolean | 'false' | 'true' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-setsize'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-sort'?: 'none' | 'other' | 'ascending' | 'descending' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-valuemax'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-valuemin'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-valuenow'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-valuetext'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dangerouslySetInnerHTML?: { __html: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCopy?: React.ClipboardEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCopyCapture?: React.ClipboardEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCut?: React.ClipboardEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCutCapture?: React.ClipboardEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onPaste?: React.ClipboardEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onPasteCapture?: React.ClipboardEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionEnd?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | React.CompositionEventHandler<HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionEndCapture?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | React.CompositionEventHandler<HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionStart?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | React.CompositionEventHandler<HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionStartCapture?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | React.CompositionEventHandler<HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionUpdate?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | React.CompositionEventHandler<HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onCompositionUpdateCapture?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | React.CompositionEventHandler<HTMLElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onFocus?: React.FocusEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onFocusCapture?: React.FocusEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onBlur?: React.FocusEventHandler<HTMLElement> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onBlurCapture?: React.FocusEventHandler<HTMLElement> | undefined;<