@blueprintjs/core

  • Version 3.45.0
  • Published
  • 5.13 MB
  • 11 dependencies
  • Apache-2.0 license

Install

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

Overview

Core styles & components

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable Alignment

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

variable Blockquote

const Blockquote: 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: {
        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;

                                      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,
                                                              }: 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> {}

                                                                                                                                                                                                                        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, 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>) => Tree<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TreeNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TreeNode<T = {}> extends React.Component<ITreeNodeProps<T>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method ofType

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