@blueprintjs/core

  • Version 4.13.0
  • Published
  • 5.89 MB
  • 11 dependencies
  • Apache-2.0 license

Install

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

Overview

Core styles & components

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable Alignment

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

variable Blockquote

const Blockquote: React.FC<any>;

    variable Boundary

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

    const Breadcrumb: React.FC<IBreadcrumbProps>;
    • Breadcrumb component.

      See Also

      • https://blueprintjs.com/docs/#core/components/breadcrumbs

    variable Code

    const Code: React.FC<any>;

      variable ContextMenu

      const ContextMenu: typeof contextMenu;

        variable DISPLAYNAME_PREFIX

        const DISPLAYNAME_PREFIX: string;

          variable Elevation

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

            variable Expander

            const Expander: React.FC;

              variable FocusStyleManager

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

                variable H1

                const H1: React.FC<any>;

                  variable H2

                  const H2: React.FC<any>;

                    variable H3

                    const H3: React.FC<any>;

                      variable H4

                      const H4: React.FC<any>;

                        variable H5

                        const H5: React.FC<any>;

                          variable H6

                          const H6: React.FC<any>;

                            variable HandleInteractionKind

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

                              variable HandleType

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

                                variable HotkeysContext

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

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

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

                                variable HotkeysDialog2

                                const HotkeysDialog2: React.FC<HotkeysDialog2Props>;

                                  variable Intent

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

                                  variable Label

                                  const Label: React.FC<any>;

                                    variable OL

                                    const OL: React.FC<any>;

                                      variable OverlayToaster

                                      const OverlayToaster: typeof Toaster;

                                        variable PanelStack2

                                        const PanelStack2: PanelStack2Component;
                                        • Panel stack (v2) component.

                                          See Also

                                          • https://blueprintjs.com/docs/#core/components/panel-stack2 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 PortalContext

                                          const PortalContext: React.Context<PortalContextOptions>;
                                          • A React context to set options for all portals in a given subtree. Do not use this PortalContext directly, instead use PortalProvider to set the options.

                                          variable Position

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

                                            variable Pre

                                            const Pre: React.FC<any>;

                                              variable UL

                                              const UL: React.FC<any>;

                                                Functions

                                                function combineRefs

                                                combineRefs: <T>(
                                                ref1: React.RefCallback<T>,
                                                ref2: React.RefCallback<T>
                                                ) => (instance: T | null) => void;
                                                • Deprecated

                                                  use mergeRefs() instead

                                                function comboMatches

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

                                                  function ContextMenuTarget

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

                                                    See Also

                                                    • https://blueprintjs.com/docs/#core/components/context-menu.decorator-usage

                                                    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>(ref: T | React.RefObject<T> | null) => T | null;

                                                      function hideHotkeysDialog

                                                      hideHotkeysDialog: () => void;

                                                        function HotkeysProvider

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

                                                          See Also

                                                          • https://blueprintjs.com/docs/#core/context/hotkeys-provider

                                                        function HotkeysTarget

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

                                                          use useHotkeys hook or <HotkeysTarget2> component

                                                        function HotkeysTarget2

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

                                                        function isPositionHorizontal

                                                        isPositionHorizontal: (position: Position) => boolean;

                                                          function isPositionVertical

                                                          isPositionVertical: (position: Position) => boolean;

                                                            function isRefCallback

                                                            isRefCallback: <T>(
                                                            value: React.Ref<T> | undefined
                                                            ) => value is React.RefCallback<T>;

                                                              function isRefObject

                                                              isRefObject: <T>(value: React.Ref<T> | undefined) => value is React.RefObject<T>;

                                                                function mergeRefs

                                                                mergeRefs: <T>(...refs: Array<React.Ref<T>>) => React.RefCallback<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 PortalProvider

                                                                PortalProvider: ({
                                                                children,
                                                                ...options
                                                                }: React.PropsWithChildren<PortalContextOptions>) => JSX.Element;
                                                                • Portal context provider.

                                                                  See Also

                                                                  • https://blueprintjs.com/docs/#core/context/portal-provider

                                                                function refHandler

                                                                refHandler: <T extends HTMLElement, K extends string>(
                                                                refTargetParent: { [k in K]: T },
                                                                refTargetKey: K,
                                                                refProp?: React.Ref<T> | undefined
                                                                ) => React.RefCallback<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>(refTarget: React.Ref<T> | undefined, ref: T | null) => void;
                                                                  • Assign the given ref to a target, either a React ref object or a callback which takes the ref as its first argument.

                                                                  function useHotkeys

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

                                                                    Parameter keys

                                                                    list of hotkeys to configure

                                                                    Parameter options

                                                                    hook options

                                                                    See Also

                                                                    • https://blueprintjs.com/docs/#core/hooks/use-hotkeys

                                                                  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> {}
                                                                                                          • Alert component.

                                                                                                            See Also

                                                                                                            • https://blueprintjs.com/docs/#core/components/alert

                                                                                                          property defaultProps

                                                                                                          static defaultProps: IAlertProps;

                                                                                                            property displayName

                                                                                                            static displayName: string;

                                                                                                              method render

                                                                                                              render: () => JSX.Element;

                                                                                                                method validateProps

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

                                                                                                                  class AnchorButton

                                                                                                                  class AnchorButton extends AbstractButton<HTMLAnchorElement> {}
                                                                                                                  • AnchorButton component.

                                                                                                                    See Also

                                                                                                                    • https://blueprintjs.com/docs/#core/components/button

                                                                                                                  property buttonRef

                                                                                                                  buttonRef: HTMLAnchorElement;

                                                                                                                    property displayName

                                                                                                                    static displayName: string;

                                                                                                                      property handleRef

                                                                                                                      protected handleRef: React.Ref<HTMLAnchorElement>;

                                                                                                                        method componentDidUpdate

                                                                                                                        componentDidUpdate: (prevProps: AnchorButtonProps) => void;

                                                                                                                          method render

                                                                                                                          render: () => JSX.Element;
                                                                                                                            class Breadcrumbs extends AbstractPureComponent2<BreadcrumbsProps> {}
                                                                                                                            • Breadcrumbs component.

                                                                                                                              See Also

                                                                                                                              • https://blueprintjs.com/docs/#core/components/breadcrumbs

                                                                                                                              Deprecated

                                                                                                                              use { Breadcrumbs2 } from "@blueprintjs/popover2"

                                                                                                                            static defaultProps: Partial<IBreadcrumbsProps>;
                                                                                                                              render: () => JSX.Element;

                                                                                                                                class Button

                                                                                                                                class Button extends AbstractButton<HTMLButtonElement> {}
                                                                                                                                • Button component.

                                                                                                                                  See Also

                                                                                                                                  • https://blueprintjs.com/docs/#core/components/button

                                                                                                                                property buttonRef

                                                                                                                                buttonRef: HTMLButtonElement;

                                                                                                                                  property displayName

                                                                                                                                  static displayName: string;

                                                                                                                                    property handleRef

                                                                                                                                    protected handleRef: React.Ref<HTMLButtonElement>;

                                                                                                                                      method componentDidUpdate

                                                                                                                                      componentDidUpdate: (prevProps: ButtonProps) => void;

                                                                                                                                        method render

                                                                                                                                        render: () => JSX.Element;

                                                                                                                                          class ButtonGroup

                                                                                                                                          class ButtonGroup extends AbstractPureComponent2<ButtonGroupProps> {}
                                                                                                                                          • Button group component.

                                                                                                                                            See Also

                                                                                                                                            • https://blueprintjs.com/docs/#core/components/button-group

                                                                                                                                          property displayName

                                                                                                                                          static displayName: string;

                                                                                                                                            method render

                                                                                                                                            render: () => JSX.Element;

                                                                                                                                              class Callout

                                                                                                                                              class Callout extends AbstractPureComponent2<CalloutProps> {}
                                                                                                                                              • Callout component.

                                                                                                                                                See Also

                                                                                                                                                • https://blueprintjs.com/docs/#core/components/callout

                                                                                                                                              property displayName

                                                                                                                                              static displayName: string;

                                                                                                                                                method render

                                                                                                                                                render: () => JSX.Element;

                                                                                                                                                  class Card

                                                                                                                                                  class Card extends AbstractPureComponent2<CardProps> {}
                                                                                                                                                  • Card component.

                                                                                                                                                    See Also

                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/card

                                                                                                                                                  property defaultProps

                                                                                                                                                  static defaultProps: ICardProps;

                                                                                                                                                    property displayName

                                                                                                                                                    static displayName: string;

                                                                                                                                                      method render

                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                        class Checkbox

                                                                                                                                                        class Checkbox extends AbstractPureComponent2<CheckboxProps, ICheckboxState> {}
                                                                                                                                                        • Checkbox component.

                                                                                                                                                          See Also

                                                                                                                                                          • https://blueprintjs.com/docs/#core/components/checkbox

                                                                                                                                                        property displayName

                                                                                                                                                        static displayName: string;

                                                                                                                                                          property input

                                                                                                                                                          input: HTMLInputElement;

                                                                                                                                                            property state

                                                                                                                                                            state: ICheckboxState;

                                                                                                                                                              method componentDidMount

                                                                                                                                                              componentDidMount: () => void;

                                                                                                                                                                method componentDidUpdate

                                                                                                                                                                componentDidUpdate: (prevProps: CheckboxProps) => void;

                                                                                                                                                                  method getDerivedStateFromProps

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

                                                                                                                                                                    method render

                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                      class Collapse

                                                                                                                                                                      class Collapse extends AbstractPureComponent2<CollapseProps, ICollapseState> {}
                                                                                                                                                                      • Collapse component.

                                                                                                                                                                        See Also

                                                                                                                                                                        • https://blueprintjs.com/docs/#core/components/collapse

                                                                                                                                                                      property defaultProps

                                                                                                                                                                      static defaultProps: Partial<ICollapseProps>;

                                                                                                                                                                        property displayName

                                                                                                                                                                        static displayName: string;

                                                                                                                                                                          property state

                                                                                                                                                                          state: ICollapseState;

                                                                                                                                                                            method componentDidMount

                                                                                                                                                                            componentDidMount: () => void;

                                                                                                                                                                              method componentDidUpdate

                                                                                                                                                                              componentDidUpdate: () => void;

                                                                                                                                                                                method getDerivedStateFromProps

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

                                                                                                                                                                                  method render

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

                                                                                                                                                                                    class CollapsibleList

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

                                                                                                                                                                                      See Also

                                                                                                                                                                                      • https://blueprintjs.com/docs/#core/components/collapsible-list

                                                                                                                                                                                      Deprecated

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

                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                    static defaultProps: Partial<ICollapsibleListProps>;

                                                                                                                                                                                      property displayName

                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                        method render

                                                                                                                                                                                        render: () => JSX.Element;

                                                                                                                                                                                          class ControlGroup

                                                                                                                                                                                          class ControlGroup extends AbstractPureComponent2<ControlGroupProps> {}
                                                                                                                                                                                          • Control group component.

                                                                                                                                                                                            See Also

                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/control-group

                                                                                                                                                                                          property displayName

                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                            method render

                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                              class Dialog

                                                                                                                                                                                              class Dialog extends AbstractPureComponent2<DialogProps> {}
                                                                                                                                                                                              • Dialog component.

                                                                                                                                                                                                See Also

                                                                                                                                                                                                • https://blueprintjs.com/docs/#core/components/dialog

                                                                                                                                                                                              constructor

                                                                                                                                                                                              constructor(props: IDialogProps);

                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                static defaultProps: IDialogProps;

                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                    method render

                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                      method validateProps

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

                                                                                                                                                                                                        class DialogStep

                                                                                                                                                                                                        class DialogStep extends AbstractPureComponent2<DialogStepProps> {}
                                                                                                                                                                                                        • Dialog step component.

                                                                                                                                                                                                          See Also

                                                                                                                                                                                                          • https://blueprintjs.com/docs/#core/components/dialog.dialogstep

                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                          method render

                                                                                                                                                                                                          render: () => JSX.Element;

                                                                                                                                                                                                            class Divider

                                                                                                                                                                                                            class Divider extends AbstractPureComponent2<IDividerProps> {}
                                                                                                                                                                                                            • Divider component.

                                                                                                                                                                                                              See Also

                                                                                                                                                                                                              • https://blueprintjs.com/docs/#core/components/divider

                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                              method render

                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                class Drawer

                                                                                                                                                                                                                class Drawer extends AbstractPureComponent2<DrawerProps> {}
                                                                                                                                                                                                                • Drawer component.

                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                  • https://blueprintjs.com/docs/#core/components/drawer

                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                static defaultProps: IDrawerProps;

                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                                      method validateProps

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

                                                                                                                                                                                                                        class EditableText

                                                                                                                                                                                                                        class EditableText extends AbstractPureComponent2<
                                                                                                                                                                                                                        EditableTextProps,
                                                                                                                                                                                                                        IEditableTextState
                                                                                                                                                                                                                        > {}
                                                                                                                                                                                                                        • EditableText component.

                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                          • https://blueprintjs.com/docs/#core/components/editable-text

                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                          property cancelEditing

                                                                                                                                                                                                                          cancelEditing: () => void;

                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                            static defaultProps: IEditableTextProps;

                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                property toggleEditing

                                                                                                                                                                                                                                toggleEditing: () => void;

                                                                                                                                                                                                                                  method componentDidMount

                                                                                                                                                                                                                                  componentDidMount: () => void;

                                                                                                                                                                                                                                    method componentDidUpdate

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

                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                                                                        class FileInput

                                                                                                                                                                                                                                        class FileInput extends AbstractPureComponent2<FileInputProps> {}
                                                                                                                                                                                                                                        • File input component.

                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                          • https://blueprintjs.com/docs/#core/components/file-input

                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                        static defaultProps: IFileInputProps;

                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                                              class FormGroup

                                                                                                                                                                                                                                              class FormGroup extends AbstractPureComponent2<FormGroupProps> {}
                                                                                                                                                                                                                                              • Form group component.

                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                • https://blueprintjs.com/docs/#core/components/form-group

                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                render: () => JSX.Element;

                                                                                                                                                                                                                                                  class Hotkey

                                                                                                                                                                                                                                                  class Hotkey extends AbstractPureComponent2<IHotkeyProps> {}
                                                                                                                                                                                                                                                  • Hotkey component.

                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/hotkeys

                                                                                                                                                                                                                                                  property defaultProps

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

                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                                                                                        method validateProps

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

                                                                                                                                                                                                                                                          class Hotkeys

                                                                                                                                                                                                                                                          class Hotkeys extends AbstractPureComponent2<IHotkeysProps> {}
                                                                                                                                                                                                                                                          • Hotkeys component.

                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/hotkeys

                                                                                                                                                                                                                                                          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> {}
                                                                                                                                                                                                                                                                  • HTML select component

                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/html-select

                                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                                                                                                                                    class HTMLTable

                                                                                                                                                                                                                                                                    class HTMLTable extends AbstractPureComponent2<HTMLTableProps> {}
                                                                                                                                                                                                                                                                    • HTML table component.

                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                      • https://blueprintjs.com/docs/#core/components/html-table

                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                    render: () => JSX.Element;

                                                                                                                                                                                                                                                                      class Icon

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

                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                        • https://blueprintjs.com/docs/#core/components/icon

                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                      static displayName: string;

                                                                                                                                                                                                                                                                        method render

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

                                                                                                                                                                                                                                                                          class InputGroup

                                                                                                                                                                                                                                                                          class InputGroup extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                          InputGroupProps2,
                                                                                                                                                                                                                                                                          IInputGroupState
                                                                                                                                                                                                                                                                          > {}
                                                                                                                                                                                                                                                                          • Input group component.

                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/text-inputs.input-group

                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                                                                            state: IInputGroupState;

                                                                                                                                                                                                                                                                              method componentDidMount

                                                                                                                                                                                                                                                                              componentDidMount: () => void;

                                                                                                                                                                                                                                                                                method componentDidUpdate

                                                                                                                                                                                                                                                                                componentDidUpdate: (prevProps: InputGroupProps2) => void;

                                                                                                                                                                                                                                                                                  method render

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

                                                                                                                                                                                                                                                                                    method validateProps

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

                                                                                                                                                                                                                                                                                      class KeyCombo

                                                                                                                                                                                                                                                                                      class KeyCombo extends AbstractPureComponent2<KeyComboTagProps> {}

                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                        static displayName: string;

                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                          render: () => JSX.Element;
                                                                                                                                                                                                                                                                                            class Menu extends AbstractPureComponent2<MenuProps> {}
                                                                                                                                                                                                                                                                                            • Menu component.

                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                              • https://blueprintjs.com/docs/#core/components/menu

                                                                                                                                                                                                                                                                                            static displayName: string;
                                                                                                                                                                                                                                                                                              render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                class MenuDivider extends React.Component<MenuDividerProps> {}
                                                                                                                                                                                                                                                                                                • Menu divider component.

                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                  • https://blueprintjs.com/docs/#core/components/menu.menu-divider

                                                                                                                                                                                                                                                                                                static displayName: string;
                                                                                                                                                                                                                                                                                                  render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                    class MenuItem extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                    MenuItemProps & React.AnchorHTMLAttributes<HTMLAnchorElement>
                                                                                                                                                                                                                                                                                                    > {}
                                                                                                                                                                                                                                                                                                    • Menu item component.

                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                      • https://blueprintjs.com/docs/#core/components/menu.menu-item

                                                                                                                                                                                                                                                                                                    static defaultProps: IMenuItemProps;
                                                                                                                                                                                                                                                                                                      static displayName: string;
                                                                                                                                                                                                                                                                                                        render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                          class MultiSlider

                                                                                                                                                                                                                                                                                                          class MultiSlider extends AbstractPureComponent2<MultiSliderProps, ISliderState> {}
                                                                                                                                                                                                                                                                                                          • Multi slider component.

                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/sliders.multi-slider

                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                          static defaultProps: IMultiSliderProps;

                                                                                                                                                                                                                                                                                                            property defaultSliderProps

                                                                                                                                                                                                                                                                                                            static defaultSliderProps: ISliderBaseProps;

                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                property Handle

                                                                                                                                                                                                                                                                                                                static Handle: React.FC<IHandleProps>;

                                                                                                                                                                                                                                                                                                                  property state

                                                                                                                                                                                                                                                                                                                  state: ISliderState;

                                                                                                                                                                                                                                                                                                                    method componentDidMount

                                                                                                                                                                                                                                                                                                                    componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

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

                                                                                                                                                                                                                                                                                                                        method getDerivedStateFromProps

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

                                                                                                                                                                                                                                                                                                                          method getSnapshotBeforeUpdate

                                                                                                                                                                                                                                                                                                                          getSnapshotBeforeUpdate: (prevProps: MultiSliderProps) => null;

                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                              method validateProps

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

                                                                                                                                                                                                                                                                                                                                class MultistepDialog

                                                                                                                                                                                                                                                                                                                                class MultistepDialog extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                MultistepDialogProps,
                                                                                                                                                                                                                                                                                                                                IMultistepDialogState
                                                                                                                                                                                                                                                                                                                                > {}
                                                                                                                                                                                                                                                                                                                                • Multi-step dialog component.

                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                  • https://blueprintjs.com/docs/#core/components/dialog.multistep-dialog

                                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                                static defaultProps: Partial<IMultistepDialogProps>;

                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                    state: IMultistepDialogState;

                                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                      componentDidUpdate: (prevProps: MultistepDialogProps) => void;

                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                        render: () => JSX.Element;
                                                                                                                                                                                                                                                                                                                                          class Navbar extends AbstractPureComponent2<NavbarProps> {}
                                                                                                                                                                                                                                                                                                                                          • Navbar component.

                                                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/navbar

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

                                                                                                                                                                                                                                                                                                                                                                        class NonIdealState

                                                                                                                                                                                                                                                                                                                                                                        class NonIdealState extends AbstractPureComponent2<NonIdealStateProps> {}
                                                                                                                                                                                                                                                                                                                                                                        • Non-ideal state component.

                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                          • https://blueprintjs.com/docs/#core/components/non-ideal-state

                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: Partial<INonIdealStateProps>;

                                                                                                                                                                                                                                                                                                                                                                          property displayName

                                                                                                                                                                                                                                                                                                                                                                          static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                            render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                              class NumericInput

                                                                                                                                                                                                                                                                                                                                                                              class NumericInput extends AbstractPureComponent2<
                                                                                                                                                                                                                                                                                                                                                                              HTMLInputProps & NumericInputProps,
                                                                                                                                                                                                                                                                                                                                                                              INumericInputState
                                                                                                                                                                                                                                                                                                                                                                              > {}
                                                                                                                                                                                                                                                                                                                                                                              • Numeric input component.

                                                                                                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                                                                                                • https://blueprintjs.com/docs/#core/components/numeric-input

                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                              static defaultProps: INumericInputProps;

                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                  property inputElement

                                                                                                                                                                                                                                                                                                                                                                                  inputElement: HTMLInputElement;

                                                                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                                                                    state: INumericInputState;

                                                                                                                                                                                                                                                                                                                                                                                      property VALUE_EMPTY

                                                                                                                                                                                                                                                                                                                                                                                      static VALUE_EMPTY: string;

                                                                                                                                                                                                                                                                                                                                                                                        property VALUE_ZERO

                                                                                                                                                                                                                                                                                                                                                                                        static VALUE_ZERO: string;

                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                            method getDerivedStateFromProps

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

                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                method validateProps

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

                                                                                                                                                                                                                                                                                                                                                                                                  class OverflowList

                                                                                                                                                                                                                                                                                                                                                                                                  class OverflowList<T> extends React.Component<
                                                                                                                                                                                                                                                                                                                                                                                                  OverflowListProps<T>,
                                                                                                                                                                                                                                                                                                                                                                                                  IOverflowListState<T>
                                                                                                                                                                                                                                                                                                                                                                                                  > {}
                                                                                                                                                                                                                                                                                                                                                                                                  • Overflow list component.

                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/overflow-list

                                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: Partial<OverflowListProps<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                      state: IOverflowListState<T>;

                                                                                                                                                                                                                                                                                                                                                                                                        method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                        componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method componentDidUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                                            method ofType

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

                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                method shouldComponentUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                                                  class Overlay

                                                                                                                                                                                                                                                                                                                                                                                                                  class Overlay extends AbstractPureComponent2<OverlayProps, IOverlayState> {}
                                                                                                                                                                                                                                                                                                                                                                                                                  • Overlay component.

                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/overlay

                                                                                                                                                                                                                                                                                                                                                                                                                  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
                                                                                                                                                                                                                                                                                                                                                                                                                                    > {}
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Panel stack component.

                                                                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://blueprintjs.com/docs/#core/components/panel-stack

                                                                                                                                                                                                                                                                                                                                                                                                                                      Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                      use PanelStack2<T>

                                                                                                                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                                                                                                                    state: IPanelStackState;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                        render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method validateProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            class Popover

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                              • https://blueprintjs.com/docs/#core/components/popover

                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                              use { Popover2 } from "@blueprintjs/popover2"

                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                            static defaultProps: IPopoverProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property popoverElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                property reposition

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                state: IPopoverState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property targetElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidUpdate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method validateProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Portal

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Portal extends React.Component<PortalProps, IPortalState> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Portal component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/portal

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                          context: PortalLegacyContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property contextTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                            static contextTypes: ValidationMap<PortalLegacyContext>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                              static defaultProps: Partial<IPortalProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  state: IPortalState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentDidUpdate: (prevProps: PortalProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ProgressBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ProgressBar extends AbstractPureComponent2<ProgressBarProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Progress bar component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • https://blueprintjs.com/docs/#core/components/progress-bar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Radio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Radio extends AbstractPureComponent2<RadioProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Radio component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • https://blueprintjs.com/docs/#core/components/radio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RadioGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RadioGroup extends AbstractPureComponent2<RadioGroupProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Radio group component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • https://blueprintjs.com/docs/#core/components/radio.radiogroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method validateProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected validateProps: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RangeSlider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RangeSlider extends AbstractPureComponent2<RangeSliderProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Range slider component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • https://blueprintjs.com/docs/#core/components/sliders.range-slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static defaultProps: IRangeSliderProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method validateProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ResizeSensor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ResizeSensor extends AbstractPureComponent2<ResizeSensorProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Resize sensor component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    It requires a single DOM element child and will error otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/resize-sensor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentDidUpdate: (prevProps: ResizeSensorProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Slider extends AbstractPureComponent2<SliderProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Slider component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • https://blueprintjs.com/docs/#core/components/sliders.slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static defaultProps: ISliderProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => JSX.Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Spinner extends AbstractPureComponent2<SpinnerProps> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Spinner component.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • https://blueprintjs.com/docs/#core/components/spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentDidUpdate: (prevProps: SpinnerProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      render: () => React.DOMElement<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultChecked?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue?: string | number | readonly string[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suppressContentEditableWarning?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suppressHydrationWarning?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accessKey?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contentEditable?: (boolean | 'true' | 'false') | 'inherit' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contextMenu?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dir?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      draggable?: (boolean | 'true' | 'false') | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hidden?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lang?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      placeholder?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      slot?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      spellCheck?: (boolean | 'true' | 'false') | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style?: React.CSSProperties | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tabIndex?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      title?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      translate?: 'yes' | 'no' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      radioGroup?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      role: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      about?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      datatype?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inlist?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefix?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resource?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeof?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      vocab?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      autoCapitalize?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      autoCorrect?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      autoSave?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      color?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      itemProp?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      itemScope?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      itemType?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      itemID?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      itemRef?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      results?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      security?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unselectable?: 'on' | 'off' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inputMode?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'none'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'search'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'tel'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'url'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'email'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'numeric'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'decimal'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      is?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-activedescendant'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-atomic'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-autocomplete'?: 'none' | 'list' | 'inline' | 'both' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-busy'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-checked'?: boolean | 'true' | 'false' | 'mixed' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-colcount'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-colindex'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-colspan'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-controls'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-current'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'time'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'location'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'page'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'step'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'date'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-describedby'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-details'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-disabled'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-dropeffect'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'none'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'link'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'move'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'copy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'execute'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'popup'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-errormessage'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-expanded'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-flowto'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-grabbed'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-haspopup'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'grid'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'menu'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'tree'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'dialog'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'listbox'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-hidden'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-invalid'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'grammar'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'spelling'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-keyshortcuts'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-label'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-labelledby'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-level'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-live'?: 'off' | 'assertive' | 'polite' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-modal'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-multiline'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-multiselectable'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-orientation'?: 'horizontal' | 'vertical' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-owns'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-placeholder'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-posinset'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-pressed'?: boolean | 'true' | 'false' | 'mixed' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-readonly'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-relevant'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'additions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'additions removals'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'additions text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'all'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'removals'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'removals additions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'removals text'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'text additions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'text removals'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-required'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-roledescription'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-rowcount'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-rowindex'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-rowspan'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-selected'?: boolean | 'true' | 'false' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-setsize'?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-sort'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'none'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'ascending'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'descending'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'other'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-valuemax': number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-valuemin': number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-valuenow': number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-valuetext'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dangerouslySetInnerHTML?: { __html: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCopy?: React.ClipboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCopyCapture?: React.ClipboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCut?: React.ClipboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCutCapture?: React.ClipboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPaste?: React.ClipboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPasteCapture?: React.ClipboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionEnd?: React.CompositionEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionEndCapture?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | React.CompositionEventHandler<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionStart?: React.CompositionEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionStartCapture?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | React.CompositionEventHandler<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionUpdate?: React.CompositionEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCompositionUpdateCapture?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | React.CompositionEventHandler<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onFocus?: React.FocusEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onFocusCapture?: React.FocusEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBlur?: React.FocusEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBlurCapture?: React.FocusEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onChange?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onChangeCapture?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBeforeInput?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBeforeInputCapture?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onInput?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onInputCapture?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onReset?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onResetCapture?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSubmit?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSubmitCapture?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onInvalid?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onInvalidCapture?: React.FormEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoad?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onError?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onErrorCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyDown?: React.KeyboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyDownCapture?: React.KeyboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyPress?: React.KeyboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyPressCapture?: React.KeyboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyUp?: React.KeyboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyUpCapture?: React.KeyboardEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAbort?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAbortCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCanPlay?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCanPlayCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCanPlayThrough?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCanPlayThroughCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDurationChange?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDurationChangeCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEmptied?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEmptiedCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEncrypted?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEncryptedCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEnded?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEndedCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadedData?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadedDataCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadedMetadata?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadedMetadataCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadStart?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onLoadStartCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPause?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPauseCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPlay?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPlayCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPlaying?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onPlayingCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onProgress?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onProgressCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onRateChange?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onRateChangeCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSeeked?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSeekedCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSeeking?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSeekingCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onStalled?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onStalledCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSuspend?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSuspendCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onTimeUpdate?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onTimeUpdateCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onVolumeChange?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onVolumeChangeCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onWaiting?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onWaitingCapture?: React.ReactEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAuxClick?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAuxClickCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onClick?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onClickCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onContextMenu?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onContextMenuCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDoubleClick?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDoubleClickCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDrag?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragEnd?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragEndCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragEnter?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragEnterCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragExit?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragExitCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragLeave?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragLeaveCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragOver?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragOverCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragStart?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDragStartCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDrop?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onDropCapture?: React.DragEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseDown?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseDownCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseEnter?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseLeave?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseMove?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseMoveCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseOut?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseOutCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseOver?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseOverCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseUp?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMouseUpCapture?: React.MouseEventHandler<any> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onSelect?: React.ReactEventHandler<any> |