@blueprintjs/core

  • Version 3.51.1
  • Published
  • 5.79 MB
  • 12 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: any;

    variable Boundary

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

    const Breadcrumb: any;

      variable Code

      const Code: any;

        variable Colors

        const Colors: {
        CERULEAN1: string;
        CERULEAN2: string;
        CERULEAN3: string;
        CERULEAN4: string;
        CERULEAN5: string;
        BLACK: string;
        BLUE1: string;
        BLUE2: string;
        BLUE3: string;
        BLUE4: string;
        BLUE5: string;
        COBALT1: string;
        COBALT2: string;
        COBALT3: string;
        COBALT4: string;
        COBALT5: string;
        DARK_GRAY1: string;
        DARK_GRAY2: string;
        DARK_GRAY3: string;
        DARK_GRAY4: string;
        DARK_GRAY5: string;
        FOREST1: string;
        FOREST2: string;
        FOREST3: string;
        FOREST4: string;
        FOREST5: string;
        GOLD1: string;
        GOLD2: string;
        GOLD3: string;
        GOLD4: string;
        GOLD5: string;
        GRAY1: string;
        GRAY2: string;
        GRAY3: string;
        GRAY4: string;
        GRAY5: string;
        GREEN1: string;
        GREEN2: string;
        GREEN3: string;
        GREEN4: string;
        GREEN5: string;
        INDIGO1: string;
        INDIGO2: string;
        INDIGO3: string;
        INDIGO4: string;
        INDIGO5: string;
        LIGHT_GRAY1: string;
        LIGHT_GRAY2: string;
        LIGHT_GRAY3: string;
        LIGHT_GRAY4: string;
        LIGHT_GRAY5: string;
        LIME1: string;
        LIME2: string;
        LIME3: string;
        LIME4: string;
        LIME5: string;
        ORANGE1: string;
        ORANGE2: string;
        ORANGE3: string;
        ORANGE4: string;
        ORANGE5: string;
        RED1: string;
        RED2: string;
        RED3: string;
        RED4: string;
        RED5: string;
        ROSE1: string;
        ROSE2: string;
        ROSE3: string;
        ROSE4: string;
        ROSE5: string;
        SEPIA1: string;
        SEPIA2: string;
        SEPIA3: string;
        SEPIA4: string;
        SEPIA5: string;
        TURQUOISE1: string;
        TURQUOISE2: string;
        TURQUOISE3: string;
        TURQUOISE4: string;
        TURQUOISE5: string;
        VERMILION1: string;
        VERMILION2: string;
        VERMILION3: string;
        VERMILION4: string;
        VERMILION5: string;
        VIOLET1: string;
        VIOLET2: string;
        VIOLET3: string;
        VIOLET4: string;
        VIOLET5: string;
        WHITE: string;
        };

          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: any;

                  variable FocusStyleManager

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

                    variable H1

                    const H1: any;

                      variable H2

                      const H2: any;

                        variable H3

                        const H3: any;

                          variable H4

                          const H4: any;

                            variable H5

                            const H5: any;

                              variable H6

                              const H6: 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: any;
                                    • 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 exisitng 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: any;

                                      variable Intent

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

                                      variable Label

                                      const Label: any;

                                        variable OL

                                        const OL: 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: any;

                                                  variable UL

                                                  const UL: 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(): any;
                                                      renderContextMenu: (e: any) => 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]: any };
                                                      componentDidMount?(): void;
                                                      shouldComponentUpdate?(
                                                      nextProps: Readonly<{}>,
                                                      nextState: Readonly<{}>,
                                                      nextContext: any
                                                      ): boolean;
                                                      componentWillUnmount?(): void;
                                                      componentDidCatch?(error: Error, errorInfo: any): 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' | 'right' | 'bottom' | 'top';

                                                        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) => any;
                                                            • 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(): any;
                                                            renderHotkeys: () => 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]: any };
                                                            shouldComponentUpdate?(
                                                            nextProps: Readonly<{}>,
                                                            nextState: Readonly<{}>,
                                                            nextContext: any
                                                            ): boolean;
                                                            componentDidCatch?(error: Error, errorInfo: any): 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) => any;
                                                            • 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: 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: () => any;

                                                                                                                      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: () => any;
                                                                                                                                    class Breadcrumbs extends AbstractPureComponent2<BreadcrumbsProps> {}
                                                                                                                                      static defaultProps: Partial<IBreadcrumbsProps>;
                                                                                                                                        render: () => any;

                                                                                                                                          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: () => any;

                                                                                                                                                      class ButtonGroup

                                                                                                                                                      class ButtonGroup extends AbstractPureComponent2<ButtonGroupProps> {}

                                                                                                                                                        property displayName

                                                                                                                                                        static displayName: string;

                                                                                                                                                          method render

                                                                                                                                                          render: () => any;

                                                                                                                                                            class Callout

                                                                                                                                                            class Callout extends AbstractPureComponent2<CalloutProps> {}
                                                                                                                                                            • This component supports the full range of HTML <div> props.

                                                                                                                                                            property displayName

                                                                                                                                                            static displayName: string;

                                                                                                                                                              method render

                                                                                                                                                              render: () => any;

                                                                                                                                                                class Card

                                                                                                                                                                class Card extends AbstractPureComponent2<CardProps> {}

                                                                                                                                                                  property defaultProps

                                                                                                                                                                  static defaultProps: ICardProps;

                                                                                                                                                                    property displayName

                                                                                                                                                                    static displayName: string;

                                                                                                                                                                      method render

                                                                                                                                                                      render: () => any;

                                                                                                                                                                        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: () => any;

                                                                                                                                                                                        class Collapse

                                                                                                                                                                                        class Collapse extends AbstractPureComponent2<CollapseProps, ICollapseState> {}

                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                          static defaultProps: 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: () => 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: () => any;

                                                                                                                                                                                                              class ControlGroup

                                                                                                                                                                                                              class ControlGroup extends AbstractPureComponent2<ControlGroupProps> {}

                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                  render: () => any;

                                                                                                                                                                                                                    class Dialog

                                                                                                                                                                                                                    class Dialog extends AbstractPureComponent2<DialogProps> {}

                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                      constructor(props: IDialogProps);

                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                        static defaultProps: IDialogProps;

                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                              method validateProps

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

                                                                                                                                                                                                                                class DialogStep

                                                                                                                                                                                                                                class DialogStep extends AbstractPureComponent2<DialogStepProps> {}

                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                      class Divider

                                                                                                                                                                                                                                      class Divider extends AbstractPureComponent2<IDividerProps> {}

                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                            class Drawer

                                                                                                                                                                                                                                            class Drawer extends AbstractPureComponent2<DrawerProps> {}

                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                              static defaultProps: IDrawerProps;

                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                  property SIZE_LARGE

                                                                                                                                                                                                                                                  static readonly SIZE_LARGE: string;
                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                    use DrawerSize.LARGE

                                                                                                                                                                                                                                                  property SIZE_SMALL

                                                                                                                                                                                                                                                  static readonly SIZE_SMALL: string;
                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                    use DrawerSize.SMALL

                                                                                                                                                                                                                                                  property SIZE_STANDARD

                                                                                                                                                                                                                                                  static readonly SIZE_STANDARD: string;
                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                    use DrawerSize.STANDARD

                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                  render: () => any;

                                                                                                                                                                                                                                                    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: () => any;

                                                                                                                                                                                                                                                                        class FileInput

                                                                                                                                                                                                                                                                        class FileInput extends AbstractPureComponent2<FileInputProps> {}

                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                          static defaultProps: IFileInputProps;

                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                              render: () => any;

                                                                                                                                                                                                                                                                                class FormGroup

                                                                                                                                                                                                                                                                                class FormGroup extends AbstractPureComponent2<FormGroupProps> {}

                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                      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: () => any;

                                                                                                                                                                                                                                                                                              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: () => any;

                                                                                                                                                                                                                                                                                                              class HTMLTable

                                                                                                                                                                                                                                                                                                              class HTMLTable extends AbstractPureComponent2<HTMLTableProps> {}

                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                                  class Icon

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

                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                      property SIZE_LARGE

                                                                                                                                                                                                                                                                                                                      static readonly SIZE_LARGE: number;
                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                        use IconSize.LARGE

                                                                                                                                                                                                                                                                                                                      property SIZE_STANDARD

                                                                                                                                                                                                                                                                                                                      static readonly SIZE_STANDARD: number;
                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                        use IconSize.STANDARD

                                                                                                                                                                                                                                                                                                                      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: () => any;

                                                                                                                                                                                                                                                                                                                                    method validateProps

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

                                                                                                                                                                                                                                                                                                                                      class KeyCombo

                                                                                                                                                                                                                                                                                                                                      class KeyCombo extends AbstractPureComponent2<KeyComboTagProps> {}

                                                                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                          render: () => any;
                                                                                                                                                                                                                                                                                                                                            class Menu extends AbstractPureComponent2<MenuProps> {}
                                                                                                                                                                                                                                                                                                                                              static displayName: string;
                                                                                                                                                                                                                                                                                                                                                static Divider: typeof MenuDivider;
                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                  use MenuDivider

                                                                                                                                                                                                                                                                                                                                                static Item: typeof MenuItem;
                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                  use MenuItem

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

                                                                                                                                                                                                                                                                                                                                                                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: any;

                                                                                                                                                                                                                                                                                                                                                                          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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                      method validateProps

                                                                                                                                                                                                                                                                                                                                                                                      protected validateProps: (props: any) => 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: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                    class Navbar extends AbstractPureComponent2<NavbarProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                        static Divider: typeof NavbarDivider;
                                                                                                                                                                                                                                                                                                                                                                                                          static Group: typeof NavbarGroup;
                                                                                                                                                                                                                                                                                                                                                                                                            static Heading: typeof NavbarHeading;
                                                                                                                                                                                                                                                                                                                                                                                                              render: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                class NavbarDivider extends AbstractPureComponent2<NavbarDividerProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                      class NavbarGroup extends AbstractPureComponent2<NavbarGroupProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: INavbarGroupProps;
                                                                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                              class NavbarHeading extends AbstractPureComponent2<NavbarHeadingProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                    class NonIdealState

                                                                                                                                                                                                                                                                                                                                                                                                                                    class NonIdealState extends AbstractPureComponent2<NonIdealStateProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                          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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method validateProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Portal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Portal extends React.Component<IPortalProps, 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: IPortalProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    state: IPortalState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentDidUpdate: (prevProps: IPortalProps) => 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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Radio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Radio extends AbstractPureComponent2<RadioProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RadioGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RadioGroup extends AbstractPureComponent2<RadioGroupProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Slider extends AbstractPureComponent2<SliderProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: ISliderProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Spinner extends AbstractPureComponent2<SpinnerProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property SIZE_LARGE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly SIZE_LARGE: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    use SpinnerSize.LARGE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property SIZE_SMALL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly SIZE_SMALL: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    use SpinnerSize.SMALL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property SIZE_STANDARD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static readonly SIZE_STANDARD: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    use SpinnerSize.STANDARD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentDidUpdate: (prevProps: SpinnerProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method validateProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Switch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Switch extends AbstractPureComponent2<SwitchProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Tab extends AbstractPureComponent2<TabProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static defaultProps: Partial<ITabProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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: string | number } | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Tag extends AbstractPureComponent2<TagProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class TextArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class TextArea extends AbstractPureComponent2<TextAreaProps, ITextAreaState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                state: ITextAreaState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property textareaElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  textareaElement: HTMLTextAreaElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentDidUpdate: (prevProps: TextAreaProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Toast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Toast extends AbstractPureComponent2<IToastProps> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static defaultProps: IToastProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentDidUpdate: (prevProps: IToastProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Toaster

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Toaster
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends AbstractPureComponent2<IToasterProps, IToasterState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        implements IToaster {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static defaultProps: IToasterProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              state: IToasterState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                clear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static create: (props?: IToasterProps, container?: HTMLElement) => IToaster;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Create a new Toaster instance that can be shared around your application. The Toaster will be rendered into a new element appended to the given container.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method dismiss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dismiss: (key: string, timeoutExpired?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getToasts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getToasts: () => IToastOptions[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        show: (props: IToastProps, key?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected validateProps: ({ maxToasts }: IToasterProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Tooltip extends AbstractPureComponent2<TooltipProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              use { Tooltip2 } from "@blueprintjs/popover2"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static defaultProps: Partial<ITooltipProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method reposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reposition: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Tree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Tree<T = {}> extends React.Component<TreeProps<T>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getNodeContentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getNodeContentElement: (nodeId: string | number) => HTMLElement | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the underlying HTML element of the Tree node with an id of nodeId. This element does not contain the children of the node, only its label and controls. If the node is not currently mounted, undefined is returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method nodeFromPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static nodeFromPath: <U>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: number[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        treeNodes?: Array<TreeNodeInfo<U>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => TreeNodeInfo<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ofType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static ofType: <U>() => new (props: TreeProps<U>)