@blueprintjs/core

const Alignment: { CENTER: 'center'; LEFT: 'left'; RIGHT: 'right' };

const AnchorButton: React.FC<any>;

const Blockquote: React.FC<any>;

const Boundary: { START: 'start'; END: 'end' };

const Breadcrumb: React.FC<BreadcrumbProps>;

const Button: React.FC<any>;

const ButtonGroup: React.FC<ButtonGroupProps>;

const Card: React.FC<CardProps>;

const CardList: React.FC<CardListProps>;

const Checkbox: React.FC<CheckboxProps>;

const Code: React.FC<any>;

const ContextMenu: React.FC<ContextMenuProps>;

const ContextMenuPopover: React.NamedExoticComponent<ContextMenuPopoverProps>;

const ControlGroup: React.FC<ControlGroupProps>;

const DISPLAYNAME_PREFIX: string;

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

const Expander: React.FC<{}>;

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

const H1: React.FC<any>;

const H2: React.FC<any>;

const H3: React.FC<any>;

const H4: React.FC<any>;

const H5: React.FC<any>;

const H6: React.FC<any>;

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

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

const HotkeysContext: React.Context<HotkeysContextInstance>;

const HotkeysDialog2: React.FC<HotkeysDialogProps>;

const HTMLSelect: React.FC<HTMLSelectProps>;

const HTMLTable: React.FC<HTMLTableProps>;

const Icon: IconComponent;

const Intent: {
    NONE: 'none';
    PRIMARY: 'primary';
    SUCCESS: 'success';
    WARNING: 'warning';
    DANGER: 'danger';
};

const Keys: {
    BACKSPACE: number;
    TAB: number;
    ENTER: number;
    SHIFT: number;
    ESCAPE: number;
    SPACE: number;
    ARROW_LEFT: number;
    ARROW_UP: number;
    ARROW_RIGHT: number;
    ARROW_DOWN: number;
    DELETE: number;
};

const Label: React.FC<any>;

const MenuItem: React.FC<MenuItemProps>;

const OL: React.FC<any>;

const PanelStack2: PanelStack2Component;

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

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';
};

const PortalContext: React.Context<PortalContextOptions>;

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';
};

const Pre: React.FC<any>;

const Radio: React.FC<ControlProps>;

const Section: React.FC<SectionProps>;

const SectionCard: React.FC<SectionCardProps>;

const Switch: React.FC<SwitchProps>;

const TabsExpander: React.FC;

const Tag: React.FC<TagProps>;

const Text: React.FC<TextProps>;

const Toaster: { create: typeof deprecatedToasterCreate };

const ToasterInstance: { create: typeof deprecatedToasterCreate };

const UL: React.FC<any>;

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

ContextMenuTargetLegacy: <
    T extends Constructor<ContextMenuTargetLegacyComponent>
>(
    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;

getKeyCombo: (e: KeyboardEvent) => KeyCombo;

getKeyComboString: (e: KeyboardEvent) => string;

getRef: <T>(ref: T | React.RefObject<T> | null) => T | null;

hideContextMenu: () => void;

hideHotkeysDialog: () => void;

hideHotkeysDialogAfterDelay: () => void;

HotkeysProvider: ({
    children,
    dialogProps,
    renderDialog,
    value,
}: HotkeysProviderProps) => JSX.Element;

HotkeysTarget: <T extends Constructor<HotkeysTargetLegacyComponent>>(
    WrappedComponent: T
) => {
    new (...args: any[]): {
        globalHotkeysEvents: HotkeysEvents;
        localHotkeysEvents: HotkeysEvents;
        componentDidMount(): void;
        componentWillUnmount(): void;
        render(): JSX.Element;
        renderHotkeys: () => React.ReactElement<
            HotkeysProps,
            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;

HotkeysTarget2: ({
    children,
    hotkeys,
    options,
}: HotkeysTarget2Props) => JSX.Element;

isHotkeysDialogShowing: () => boolean;

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

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

mergeRefs: <T>(...refs: Array<React.Ref<T>>) => React.RefCallback<T>;

parseKeyCombo: (combo: string) => KeyCombo;

Portal: typeof Portal;

PortalProvider: ({
    children,
    portalClassName,
    portalContainer,
}: React.PropsWithChildren<PortalContextOptions>) => JSX.Element;

refHandler: <T extends HTMLElement, K extends string>(
    refTargetParent: { [k in K]: T },
    refTargetKey: K,
    refProp?: React.Ref<T> | undefined
) => React.RefCallback<T>;

removeNonHTMLProps: (
    props: { [key: string]: any },
    invalidProps?: string[],
    shouldMerge?: boolean
) => { [key: string]: any };

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

setRef: <T>(refTarget: React.Ref<T> | undefined, ref: T | null) => void;

showContextMenu: (props: Omit<ContextMenuPopoverProps, 'isOpen'>) => void;

showHotkeysDialog: (hotkeys: HotkeyProps[]) => void;

useAsyncControllableValue: <E extends HTMLInputElement | HTMLTextAreaElement>(
    props: UseAsyncControllableValueProps<E>
) => {
    onChange: React.ChangeEventHandler<E>;
    onCompositionEnd: React.CompositionEventHandler<E>;
    onCompositionStart: React.CompositionEventHandler<E>;
    value: string | number | readonly string[] | undefined;
};

useHotkeys: (
    keys: readonly HotkeyConfig[],
    options?: UseHotkeysOptions
) => UseHotkeysReturnValue;