import * as vue from 'vue';
import { Ref, ComputedRef, CSSProperties, InjectionKey, PropType, ExtractPropTypes, StyleValue } from 'vue';

type OnCleanup = (cleanupFn: () => void) => void;

declare const _default$6: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
}>, {
    /**
     * @description Arrow element
     */
    arrowRef: vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
}>> & Readonly<{}>, {
    readonly arrowOffset: number;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const top: "top";
declare const bottom: "bottom";
declare const right: "right";
declare const left: "left";
declare type BasePlacement = typeof top | typeof bottom | typeof right | typeof left;
declare type VariationPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
declare type AutoPlacement = "auto" | "auto-start" | "auto-end";
declare type Placement = AutoPlacement | BasePlacement | VariationPlacement;
declare const beforeRead: "beforeRead";
declare const read: "read";
declare const afterRead: "afterRead";
declare const beforeMain: "beforeMain";
declare const main: "main";
declare const afterMain: "afterMain";
declare const beforeWrite: "beforeWrite";
declare const write: "write";
declare const afterWrite: "afterWrite";
declare type ModifierPhases = typeof beforeRead | typeof read | typeof afterRead | typeof beforeMain | typeof main | typeof afterMain | typeof beforeWrite | typeof write | typeof afterWrite;

declare type Obj = {
    [key: string]: any;
};
declare type VisualViewport = EventTarget & {
    width: number;
    height: number;
    offsetLeft: number;
    offsetTop: number;
    scale: number;
};
declare type Window = {
    innerHeight: number;
    offsetHeight: number;
    innerWidth: number;
    offsetWidth: number;
    pageXOffset: number;
    pageYOffset: number;
    getComputedStyle: typeof getComputedStyle;
    addEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
    removeEventListener(type: any, listener: any, optionsOrUseCapture?: any): void;
    Element: Element;
    HTMLElement: HTMLElement;
    Node: Node;
    toString(): "[object Window]";
    devicePixelRatio: number;
    visualViewport?: VisualViewport;
    ShadowRoot: ShadowRoot;
};
declare type Rect = {
    width: number;
    height: number;
    x: number;
    y: number;
};
declare type Offsets = {
    y: number;
    x: number;
};
declare type PositioningStrategy = "absolute" | "fixed";
declare type StateRects = {
    reference: Rect;
    popper: Rect;
};
declare type OffsetData = {
    [key in Placement]?: Offsets;
};
declare type State = {
    elements: {
        reference: Element | VirtualElement;
        popper: HTMLElement;
        arrow?: HTMLElement;
    };
    options: OptionsGeneric<any>;
    placement: Placement;
    strategy: PositioningStrategy;
    orderedModifiers: Array<Modifier<any, any>>;
    rects: StateRects;
    scrollParents: {
        reference: Array<Element | Window | VisualViewport>;
        popper: Array<Element | Window | VisualViewport>;
    };
    styles: {
        [key: string]: Partial<CSSStyleDeclaration>;
    };
    attributes: {
        [key: string]: {
            [key: string]: string | boolean;
        };
    };
    modifiersData: {
        arrow?: {
            x?: number;
            y?: number;
            centerOffset: number;
        };
        hide?: {
            isReferenceHidden: boolean;
            hasPopperEscaped: boolean;
            referenceClippingOffsets: SideObject;
            popperEscapeOffsets: SideObject;
        };
        offset?: OffsetData;
        preventOverflow?: Offsets;
        popperOffsets?: Offsets;
        [key: string]: any;
    };
    reset: boolean;
};
declare type SetAction<S> = S | ((prev: S) => S);
declare type Instance = {
    state: State;
    destroy: () => void;
    forceUpdate: () => void;
    update: () => Promise<Partial<State>>;
    setOptions: (setOptionsAction: SetAction<Partial<OptionsGeneric<any>>>) => Promise<Partial<State>>;
};
declare type ModifierArguments<Options extends Obj> = {
    state: State;
    instance: Instance;
    options: Partial<Options>;
    name: string;
};
declare type Modifier<Name, Options extends Obj> = {
    name: Name;
    enabled: boolean;
    phase: ModifierPhases;
    requires?: Array<string>;
    requiresIfExists?: Array<string>;
    fn: (arg0: ModifierArguments<Options>) => State | void;
    effect?: (arg0: ModifierArguments<Options>) => (() => void) | void;
    options?: Partial<Options>;
    data?: Obj;
};
declare type Options = {
    placement: Placement;
    modifiers: Array<Partial<Modifier<any, any>>>;
    strategy: PositioningStrategy;
    onFirstUpdate?: (arg0: Partial<State>) => void;
};
declare type OptionsGeneric<TModifier> = {
    placement: Placement;
    modifiers: Array<TModifier>;
    strategy: PositioningStrategy;
    onFirstUpdate?: (arg0: Partial<State>) => void;
};
declare type SideObject = {
    top: number;
    left: number;
    right: number;
    bottom: number;
};
declare type VirtualElement = {
    getBoundingClientRect: () => ClientRect | DOMRect;
    contextElement?: Element;
};

interface Measurable {
    getBoundingClientRect: () => DOMRect;
}
/**
 * triggerRef indicates the element that triggers popper
 * contentRef indicates the element of popper content
 * referenceRef indicates the element that popper content relative with
 */
interface ElPopperInjectionContext {
    triggerRef: Ref<Measurable | undefined>;
    contentRef: Ref<HTMLElement | undefined>;
    popperInstanceRef: Ref<Instance | undefined>;
    referenceRef: Ref<Measurable | undefined>;
    role: ComputedRef<string>;
}
interface ElPopperContentInjectionContext {
    arrowRef: Ref<HTMLElement | undefined>;
    arrowOffset: Ref<number | undefined>;
    arrowStyle: ComputedRef<CSSProperties>;
}
declare const POPPER_INJECTION_KEY: InjectionKey<ElPopperInjectionContext>;
declare const POPPER_CONTENT_INJECTION_KEY: InjectionKey<ElPopperContentInjectionContext>;

declare function __VLS_template$5(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};
type __VLS_TemplateResult$5 = ReturnType<typeof __VLS_template$5>;
declare const __VLS_component$5: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly role: {
        readonly type: vue.PropType<typeof roleTypes[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
}>, {
    triggerRef: vue.Ref<Measurable | undefined>;
    contentRef: vue.Ref<HTMLElement | undefined>;
    popperInstanceRef: vue.Ref<Instance | undefined>;
    referenceRef: vue.Ref<Measurable | undefined>;
    role: vue.ComputedRef<string>;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly role: {
        readonly type: vue.PropType<typeof roleTypes[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
}>> & Readonly<{}>, {
    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
declare const _default$5: __VLS_WithTemplateSlots$5<typeof __VLS_component$5, __VLS_TemplateResult$5["slots"]>;

type __VLS_WithTemplateSlots$5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const Effect: {
    readonly LIGHT: "light";
    readonly DARK: "dark";
};
declare const roleTypes: readonly ["dialog", "grid", "group", "listbox", "menu", "navigation", "tooltip", "tree"];
type PopperEffect = 'light' | 'dark';
type PopperTrigger = 'click' | 'contextmenu' | 'hover' | 'focus';
declare const popperProps: {
    readonly role: {
        readonly type: PropType<(typeof roleTypes)[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
};
type PopperProps = ExtractPropTypes<typeof popperProps>;
type PopperInstance = InstanceType<typeof _default$5>;
/** @deprecated use `popperProps` instead, and it will be deprecated in the next major version */
declare const usePopperProps: {
    readonly role: {
        readonly type: PropType<(typeof roleTypes)[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
};
/** @deprecated use `PopperProps` instead, and it will be deprecated in the next major version */
type UsePopperProps = PopperProps;

declare function updatePopper$1(shouldUpdateZIndex?: boolean): void;
declare function __VLS_template$4(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {
        contentRef: HTMLDivElement;
    };
    attrs: Partial<{}>;
};
type __VLS_TemplateResult$4 = ReturnType<typeof __VLS_template$4>;
declare const __VLS_component$4: vue.DefineComponent<vue.ExtractPropTypes<{
    ariaLabel: {
        readonly type: StringConstructor;
    };
    id: {
        type: StringConstructor;
    };
    style: {
        type: vue.PropType<vue.StyleValue>;
    };
    className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    visible: {
        type: BooleanConstructor;
    };
    enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    pure: {
        type: BooleanConstructor;
    };
    focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    virtualTriggering: {
        type: BooleanConstructor;
    };
    zIndex: {
        type: NumberConstructor;
    };
    boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
}>, {
    /**
     * @description popper content element
     */
    popperContentRef: vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
    /**
     * @description popperjs instance
     */
    popperInstanceRef: vue.ComputedRef<Instance | undefined>;
    /**
     * @description method for updating popper
     */
    updatePopper: typeof updatePopper$1;
    /**
     * @description content style
     */
    contentStyle: vue.ComputedRef<vue.StyleValue[]>;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    close: () => void;
    blur: () => void;
    focus: () => void;
    mouseenter: (evt: MouseEvent) => void;
    mouseleave: (evt: MouseEvent) => void;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    ariaLabel: {
        readonly type: StringConstructor;
    };
    id: {
        type: StringConstructor;
    };
    style: {
        type: vue.PropType<vue.StyleValue>;
    };
    className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    visible: {
        type: BooleanConstructor;
    };
    enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    pure: {
        type: BooleanConstructor;
    };
    focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    virtualTriggering: {
        type: BooleanConstructor;
    };
    zIndex: {
        type: NumberConstructor;
    };
    boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
}>> & Readonly<{
    onClose?: (() => any) | undefined;
    onBlur?: (() => any) | undefined;
    onFocus?: (() => any) | undefined;
    onMouseenter?: ((evt: MouseEvent) => any) | undefined;
    onMouseleave?: ((evt: MouseEvent) => any) | undefined;
}>, {
    placement: Placement;
    strategy: "fixed" | "absolute";
    effect: string;
    offset: number;
    boundariesPadding: number;
    fallbackPlacements: Placement[];
    gpuAcceleration: boolean;
    popperOptions: Partial<Options>;
    visible: boolean;
    enterable: boolean;
    pure: boolean;
    focusOnShow: boolean;
    trapping: boolean;
    stopPopperMouseEvent: boolean;
    virtualTriggering: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
declare const _default$4: __VLS_WithTemplateSlots$4<typeof __VLS_component$4, __VLS_TemplateResult$4["slots"]>;

type __VLS_WithTemplateSlots$4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare function __VLS_template$3(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};
type __VLS_TemplateResult$3 = ReturnType<typeof __VLS_template$3>;
declare const __VLS_component$3: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly virtualRef: {
        readonly type: vue.PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
}>, {
    /**
     * @description trigger element
     */
    triggerRef: vue.Ref<Measurable | undefined, Measurable | undefined>;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly virtualRef: {
        readonly type: vue.PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
}>> & Readonly<{}>, {
    readonly open: boolean;
    readonly virtualTriggering: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
declare const _default$3: __VLS_WithTemplateSlots$3<typeof __VLS_component$3, __VLS_TemplateResult$3["slots"]>;

type __VLS_WithTemplateSlots$3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const popperArrowProps: {
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
};
type PopperArrowProps = ExtractPropTypes<typeof popperArrowProps>;
type PopperArrowInstance = InstanceType<typeof _default$6>;
/** @deprecated use `popperArrowProps` instead, and it will be deprecated in the next major version */
declare const usePopperArrowProps: {
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
};
/** @deprecated use `PopperArrowProps` instead, and it will be deprecated in the next major version */
type UsePopperArrowProps = PopperArrowProps;
/** @deprecated use `PopperArrowInstance` instead, and it will be deprecated in the next major version */
type ElPopperArrowInstance = PopperArrowInstance;

type ClassObjectType = Record<string, boolean>;
type ClassType = string | ClassObjectType | ClassType[];
declare const POSITIONING_STRATEGIES: readonly ["fixed", "absolute"];
interface CreatePopperInstanceParams {
    referenceEl: Measurable;
    popperContentEl: HTMLElement;
    arrowEl: HTMLElement | undefined;
}
declare const popperCoreConfigProps: {
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * @description offset of the Tooltip
     */
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    /**
     * @description position of Tooltip
     */
    readonly placement: {
        readonly type: PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    /**
     * @description [popper.js](https://popper.js.org/docs/v2/) parameters
     */
    readonly popperOptions: {
        readonly type: PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: PropType<(typeof POSITIONING_STRATEGIES)[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
};
type PopperCoreConfigProps = ExtractPropTypes<typeof popperCoreConfigProps>;
declare const popperContentProps: {
    ariaLabel: {
        readonly type: StringConstructor;
    };
    id: {
        type: StringConstructor;
    };
    style: {
        type: PropType<StyleValue>;
    };
    className: {
        type: PropType<ClassType>;
    };
    effect: {
        type: PropType<PopperEffect | string>;
        default: string;
    };
    visible: {
        type: BooleanConstructor;
    };
    enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    pure: {
        type: BooleanConstructor;
    };
    focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    popperClass: {
        type: PropType<ClassType>;
    };
    popperStyle: {
        type: PropType<StyleValue>;
    };
    referenceEl: {
        type: PropType<HTMLElement>;
    };
    triggerTargetEl: {
        type: PropType<HTMLElement>;
    };
    stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    virtualTriggering: {
        type: BooleanConstructor;
    };
    zIndex: {
        type: NumberConstructor;
    };
    boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    fallbackPlacements: {
        readonly type: PropType<Placement[]>;
        readonly default: undefined;
    };
    gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    placement: {
        readonly type: PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    popperOptions: {
        readonly type: PropType<Partial<Options>>;
        readonly default: () => {};
    };
    strategy: {
        readonly type: PropType<(typeof POSITIONING_STRATEGIES)[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
};
type PopperContentProps = ExtractPropTypes<typeof popperContentProps>;
declare const popperContentEmits: {
    mouseenter: (evt: MouseEvent) => boolean;
    mouseleave: (evt: MouseEvent) => boolean;
    focus: () => boolean;
    blur: () => boolean;
    close: () => boolean;
};
type PopperContentEmits = typeof popperContentEmits;
type PopperContentInstance = InstanceType<typeof _default$4>;
/** @deprecated use `popperCoreConfigProps` instead, and it will be deprecated in the next major version */
declare const usePopperCoreConfigProps: {
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * @description offset of the Tooltip
     */
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    /**
     * @description position of Tooltip
     */
    readonly placement: {
        readonly type: PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    /**
     * @description [popper.js](https://popper.js.org/docs/v2/) parameters
     */
    readonly popperOptions: {
        readonly type: PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: PropType<(typeof POSITIONING_STRATEGIES)[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
};
/** @deprecated use `popperContentProps` instead, and it will be deprecated in the next major version */
declare const usePopperContentProps: {
    ariaLabel: {
        readonly type: StringConstructor;
    };
    id: {
        type: StringConstructor;
    };
    style: {
        type: PropType<StyleValue>;
    };
    className: {
        type: PropType<ClassType>;
    };
    effect: {
        type: PropType<PopperEffect | string>;
        default: string;
    };
    visible: {
        type: BooleanConstructor;
    };
    enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    pure: {
        type: BooleanConstructor;
    };
    focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    popperClass: {
        type: PropType<ClassType>;
    };
    popperStyle: {
        type: PropType<StyleValue>;
    };
    referenceEl: {
        type: PropType<HTMLElement>;
    };
    triggerTargetEl: {
        type: PropType<HTMLElement>;
    };
    stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    virtualTriggering: {
        type: BooleanConstructor;
    };
    zIndex: {
        type: NumberConstructor;
    };
    boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    fallbackPlacements: {
        readonly type: PropType<Placement[]>;
        readonly default: undefined;
    };
    gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    placement: {
        readonly type: PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    popperOptions: {
        readonly type: PropType<Partial<Options>>;
        readonly default: () => {};
    };
    strategy: {
        readonly type: PropType<(typeof POSITIONING_STRATEGIES)[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
};
/** @deprecated use `popperContentEmits` instead, and it will be deprecated in the next major version */
declare const usePopperContentEmits: {
    mouseenter: (evt: MouseEvent) => boolean;
    mouseleave: (evt: MouseEvent) => boolean;
    focus: () => boolean;
    blur: () => boolean;
    close: () => boolean;
};
/** @deprecated use `PopperCoreConfigProps` instead, and it will be deprecated in the next major version */
type UsePopperCoreConfigProps = PopperCoreConfigProps;
/** @deprecated use `PopperContentProps` instead, and it will be deprecated in the next major version */
type UsePopperContentProps = PopperContentProps;
/** @deprecated use `PopperContentInstance` instead, and it will be deprecated in the next major version */
type ElPopperArrowContent = PopperContentInstance;

declare const popperTriggerProps: {
    readonly virtualRef: {
        readonly type: PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
};
type PopperTriggerProps = typeof popperTriggerProps;
type PopperTriggerInstance = InstanceType<typeof _default$3>;
/** @deprecated use `popperTriggerProps` instead, and it will be deprecated in the next major version */
declare const usePopperTriggerProps: {
    readonly virtualRef: {
        readonly type: PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
};
/** @deprecated use `PopperTriggerInstance` instead, and it will be deprecated in the next major version */
type ElPopperArrowTrigger = PopperTriggerInstance;

type Arrayable<T> = T | T[];

type TooltipTriggerType = 'hover' | 'focus' | 'click' | 'contextmenu';
declare const useTooltipTriggerProps: {
    /**
     * @description whether Tooltip is disabled
     */
    readonly disabled: BooleanConstructor;
    /**
     * @description How should the tooltip be triggered (to show)
     */
    readonly trigger: {
        readonly type: PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    /**
     * @description When you click the mouse to focus on the trigger element, you can define a set of keyboard codes to control the display of tooltip through the keyboard
     */
    readonly triggerKeys: {
        readonly type: PropType<string[]>;
        readonly default: () => string[];
    };
    readonly virtualRef: {
        readonly type: PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
};
type ElTooltipTriggerProps = ExtractPropTypes<typeof useTooltipTriggerProps>;

declare function updatePopper(): void;
declare function isFocusInsideContent(event?: FocusEvent): boolean | undefined;
declare function __VLS_template$2(): {
    slots: {
        default?(_: {}): any;
        content?(_: {}): any;
    };
    refs: {
        popperRef: ({
            $: vue.ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
            }> & Omit<{
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: vue.Slot<any> | undefined;
            }>;
            $root: vue.ComponentPublicInstance | null;
            $parent: vue.ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                readonly role: {
                    readonly type: vue.PropType<typeof roleTypes[number]>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "tooltip";
                };
            }>> & Readonly<{}>, {
                triggerRef: vue.Ref<Measurable | undefined>;
                contentRef: vue.Ref<HTMLElement | undefined>;
                popperInstanceRef: vue.Ref<Instance | undefined>;
                referenceRef: vue.Ref<Measurable | undefined>;
                role: vue.ComputedRef<string>;
            }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
            }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof vue.nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
        } & Readonly<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }> & Omit<Readonly<vue.ExtractPropTypes<{
            readonly role: {
                readonly type: vue.PropType<typeof roleTypes[number]>;
                readonly validator: (val: string) => boolean;
                readonly default: "tooltip";
            };
        }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
            triggerRef: vue.Ref<Measurable | undefined>;
            contentRef: vue.Ref<HTMLElement | undefined>;
            popperInstanceRef: vue.Ref<Instance | undefined>;
            referenceRef: vue.Ref<Measurable | undefined>;
            role: vue.ComputedRef<string>;
        }> & {} & vue.ComponentCustomProperties & {} & {
            $slots: {
                default?(_: {}): any;
            };
        }) | null;
        contentRef: ({
            $: vue.ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                readonly disabled: boolean;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: number;
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly content: string;
                readonly offset: number;
                readonly boundariesPadding: number;
                readonly fallbackPlacements: Placement[];
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean | null;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly rawContent: boolean;
                readonly persistent: boolean;
                readonly teleported: boolean;
            }> & Omit<{
                readonly disabled: boolean;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: number;
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly content: string;
                readonly offset: number;
                readonly boundariesPadding: number;
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean | null;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly rawContent: boolean;
                readonly persistent: boolean;
                readonly teleported: boolean;
                readonly ariaLabel?: string | undefined;
                readonly transition?: string | undefined;
                readonly zIndex?: number | undefined;
                readonly style?: vue.StyleValue;
                readonly id?: string | undefined;
                readonly fallbackPlacements?: Placement[] | undefined;
                readonly className?: (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
                readonly popperClass?: (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
                readonly popperStyle?: vue.StyleValue;
                readonly referenceEl?: HTMLElement | undefined;
                readonly triggerTargetEl?: HTMLElement | undefined;
                readonly appendTo?: string | HTMLElement | undefined;
            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "disabled" | "showAfter" | "hideAfter" | "autoClose" | "placement" | "strategy" | "effect" | "content" | "offset" | "boundariesPadding" | "fallbackPlacements" | "gpuAcceleration" | "popperOptions" | "visible" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "virtualTriggering" | "rawContent" | "persistent" | "teleported">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: vue.Slot<any> | undefined;
            }>;
            $root: vue.ComponentPublicInstance | null;
            $parent: vue.ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                readonly ariaLabel: {
                    readonly type: StringConstructor;
                };
                readonly appendTo: {
                    readonly type: vue.PropType<string | HTMLElement>;
                };
                readonly content: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly rawContent: BooleanConstructor;
                readonly persistent: BooleanConstructor;
                readonly visible: {
                    readonly type: vue.PropType<boolean | null>;
                    readonly default: null;
                };
                readonly transition: StringConstructor;
                readonly teleported: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly disabled: BooleanConstructor;
                readonly id: {
                    type: StringConstructor;
                };
                readonly style: {
                    type: vue.PropType<vue.StyleValue>;
                };
                readonly className: {
                    type: vue.PropType<string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | any)[])[])[])[])[])[])[])[])[])[])[]>;
                };
                readonly effect: {
                    type: vue.PropType<PopperEffect | string>;
                    default: string;
                };
                readonly enterable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly pure: {
                    type: BooleanConstructor;
                };
                readonly focusOnShow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly trapping: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly popperClass: {
                    type: vue.PropType<string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | any)[])[])[])[])[])[])[])[])[])[])[]>;
                };
                readonly popperStyle: {
                    type: vue.PropType<vue.StyleValue>;
                };
                readonly referenceEl: {
                    type: vue.PropType<HTMLElement>;
                };
                readonly triggerTargetEl: {
                    type: vue.PropType<HTMLElement>;
                };
                readonly stopPopperMouseEvent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly virtualTriggering: {
                    type: BooleanConstructor;
                };
                readonly zIndex: {
                    type: NumberConstructor;
                };
                readonly boundariesPadding: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly fallbackPlacements: {
                    readonly type: vue.PropType<Placement[]>;
                    readonly default: undefined;
                };
                readonly gpuAcceleration: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly offset: {
                    readonly type: NumberConstructor;
                    readonly default: 12;
                };
                readonly placement: {
                    readonly type: vue.PropType<Placement>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "bottom";
                };
                readonly popperOptions: {
                    readonly type: vue.PropType<Partial<Options>>;
                    readonly default: () => {};
                };
                readonly strategy: {
                    readonly type: vue.PropType<"fixed" | "absolute">;
                    readonly validator: (val: string) => boolean;
                    readonly default: "absolute";
                };
                readonly showAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly hideAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 200;
                };
                readonly autoClose: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
            }>> & Readonly<{}>, {
                contentRef: vue.Ref<any, any>;
            }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                readonly disabled: boolean;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: number;
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly content: string;
                readonly offset: number;
                readonly boundariesPadding: number;
                readonly fallbackPlacements: Placement[];
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean | null;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly rawContent: boolean;
                readonly persistent: boolean;
                readonly teleported: boolean;
            }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof vue.nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
        } & Readonly<{
            readonly disabled: boolean;
            readonly showAfter: number;
            readonly hideAfter: number;
            readonly autoClose: number;
            readonly placement: Placement;
            readonly strategy: "fixed" | "absolute";
            readonly effect: string;
            readonly content: string;
            readonly offset: number;
            readonly boundariesPadding: number;
            readonly fallbackPlacements: Placement[];
            readonly gpuAcceleration: boolean;
            readonly popperOptions: Partial<Options>;
            readonly visible: boolean | null;
            readonly enterable: boolean;
            readonly pure: boolean;
            readonly focusOnShow: boolean;
            readonly trapping: boolean;
            readonly stopPopperMouseEvent: boolean;
            readonly virtualTriggering: boolean;
            readonly rawContent: boolean;
            readonly persistent: boolean;
            readonly teleported: boolean;
        }> & Omit<Readonly<vue.ExtractPropTypes<{
            readonly ariaLabel: {
                readonly type: StringConstructor;
            };
            readonly appendTo: {
                readonly type: vue.PropType<string | HTMLElement>;
            };
            readonly content: {
                readonly type: StringConstructor;
                readonly default: "";
            };
            readonly rawContent: BooleanConstructor;
            readonly persistent: BooleanConstructor;
            readonly visible: {
                readonly type: vue.PropType<boolean | null>;
                readonly default: null;
            };
            readonly transition: StringConstructor;
            readonly teleported: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly disabled: BooleanConstructor;
            readonly id: {
                type: StringConstructor;
            };
            readonly style: {
                type: vue.PropType<vue.StyleValue>;
            };
            readonly className: {
                type: vue.PropType<string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]>;
            };
            readonly effect: {
                type: vue.PropType<PopperEffect | string>;
                default: string;
            };
            readonly enterable: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly pure: {
                type: BooleanConstructor;
            };
            readonly focusOnShow: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly trapping: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly popperClass: {
                type: vue.PropType<string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]>;
            };
            readonly popperStyle: {
                type: vue.PropType<vue.StyleValue>;
            };
            readonly referenceEl: {
                type: vue.PropType<HTMLElement>;
            };
            readonly triggerTargetEl: {
                type: vue.PropType<HTMLElement>;
            };
            readonly stopPopperMouseEvent: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly virtualTriggering: {
                type: BooleanConstructor;
            };
            readonly zIndex: {
                type: NumberConstructor;
            };
            readonly boundariesPadding: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly fallbackPlacements: {
                readonly type: vue.PropType<Placement[]>;
                readonly default: undefined;
            };
            readonly gpuAcceleration: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly offset: {
                readonly type: NumberConstructor;
                readonly default: 12;
            };
            readonly placement: {
                readonly type: vue.PropType<Placement>;
                readonly validator: (val: string) => boolean;
                readonly default: "bottom";
            };
            readonly popperOptions: {
                readonly type: vue.PropType<Partial<Options>>;
                readonly default: () => {};
            };
            readonly strategy: {
                readonly type: vue.PropType<"fixed" | "absolute">;
                readonly validator: (val: string) => boolean;
                readonly default: "absolute";
            };
            readonly showAfter: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly hideAfter: {
                readonly type: NumberConstructor;
                readonly default: 200;
            };
            readonly autoClose: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
        }>> & Readonly<{}>, "contentRef" | ("disabled" | "showAfter" | "hideAfter" | "autoClose" | "placement" | "strategy" | "effect" | "content" | "offset" | "boundariesPadding" | "fallbackPlacements" | "gpuAcceleration" | "popperOptions" | "visible" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "virtualTriggering" | "rawContent" | "persistent" | "teleported")> & vue.ShallowUnwrapRef<{
            contentRef: vue.Ref<any, any>;
        }> & {} & vue.ComponentCustomProperties & {} & {
            $slots: {
                default?(_: {}): any;
            };
        }) | null;
    };
    attrs: Partial<{}>;
};
type __VLS_TemplateResult$2 = ReturnType<typeof __VLS_template$2>;
declare const __VLS_component$2: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly showArrow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
    readonly disabled: BooleanConstructor;
    readonly trigger: {
        readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    readonly triggerKeys: {
        readonly type: vue.PropType<string[]>;
        readonly default: () => string[];
    };
    readonly virtualRef: {
        readonly type: vue.PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
    readonly ariaLabel: {
        readonly type: StringConstructor;
    };
    readonly appendTo: {
        readonly type: vue.PropType<string | HTMLElement>;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly rawContent: BooleanConstructor;
    readonly persistent: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly style: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    readonly enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly pure: {
        type: BooleanConstructor;
    };
    readonly focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly zIndex: {
        type: NumberConstructor;
    };
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly "onUpdate:visible": {
        readonly type: vue.PropType<(val: boolean) => void>;
    };
    readonly role: {
        readonly type: vue.PropType<typeof roleTypes[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
}>, {
    /**
     * @description el-popper component instance
     */
    popperRef: vue.Ref<({
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }> & Omit<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance | null;
        $parent: vue.ComponentPublicInstance | null;
        $host: Element | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            readonly role: {
                readonly type: vue.PropType<typeof roleTypes[number]>;
                readonly validator: (val: string) => boolean;
                readonly default: "tooltip";
            };
        }>> & Readonly<{}>, {
            triggerRef: vue.Ref<Measurable | undefined>;
            contentRef: vue.Ref<HTMLElement | undefined>;
            popperInstanceRef: vue.Ref<Instance | undefined>;
            referenceRef: vue.Ref<Measurable | undefined>;
            role: vue.ComputedRef<string>;
        }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
            beforeCreate?: (() => void) | (() => void)[];
            created?: (() => void) | (() => void)[];
            beforeMount?: (() => void) | (() => void)[];
            mounted?: (() => void) | (() => void)[];
            beforeUpdate?: (() => void) | (() => void)[];
            updated?: (() => void) | (() => void)[];
            activated?: (() => void) | (() => void)[];
            deactivated?: (() => void) | (() => void)[];
            beforeDestroy?: (() => void) | (() => void)[];
            beforeUnmount?: (() => void) | (() => void)[];
            destroyed?: (() => void) | (() => void)[];
            unmounted?: (() => void) | (() => void)[];
            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
    } & Readonly<{
        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
    }> & Omit<Readonly<vue.ExtractPropTypes<{
        readonly role: {
            readonly type: vue.PropType<typeof roleTypes[number]>;
            readonly validator: (val: string) => boolean;
            readonly default: "tooltip";
        };
    }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
        triggerRef: vue.Ref<Measurable | undefined>;
        contentRef: vue.Ref<HTMLElement | undefined>;
        popperInstanceRef: vue.Ref<Instance | undefined>;
        referenceRef: vue.Ref<Measurable | undefined>;
        role: vue.ComputedRef<string>;
    }> & {} & vue.ComponentCustomProperties & {} & {
        $slots: {
            default?(_: {}): any;
        };
    }) | undefined, ({
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }> & Omit<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance | null;
        $parent: vue.ComponentPublicInstance | null;
        $host: Element | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            readonly role: {
                readonly type: vue.PropType<typeof roleTypes[number]>;
                readonly validator: (val: string) => boolean;
                readonly default: "tooltip";
            };
        }>> & Readonly<{}>, {
            triggerRef: vue.Ref<Measurable | undefined>;
            contentRef: vue.Ref<HTMLElement | undefined>;
            popperInstanceRef: vue.Ref<Instance | undefined>;
            referenceRef: vue.Ref<Measurable | undefined>;
            role: vue.ComputedRef<string>;
        }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
            beforeCreate?: (() => void) | (() => void)[];
            created?: (() => void) | (() => void)[];
            beforeMount?: (() => void) | (() => void)[];
            mounted?: (() => void) | (() => void)[];
            beforeUpdate?: (() => void) | (() => void)[];
            updated?: (() => void) | (() => void)[];
            activated?: (() => void) | (() => void)[];
            deactivated?: (() => void) | (() => void)[];
            beforeDestroy?: (() => void) | (() => void)[];
            beforeUnmount?: (() => void) | (() => void)[];
            destroyed?: (() => void) | (() => void)[];
            unmounted?: (() => void) | (() => void)[];
            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
    } & Readonly<{
        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
    }> & Omit<Readonly<vue.ExtractPropTypes<{
        readonly role: {
            readonly type: vue.PropType<typeof roleTypes[number]>;
            readonly validator: (val: string) => boolean;
            readonly default: "tooltip";
        };
    }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
        triggerRef: vue.Ref<Measurable | undefined>;
        contentRef: vue.Ref<HTMLElement | undefined>;
        popperInstanceRef: vue.Ref<Instance | undefined>;
        referenceRef: vue.Ref<Measurable | undefined>;
        role: vue.ComputedRef<string>;
    }> & {} & vue.ComponentCustomProperties & {} & {
        $slots: {
            default?(_: {}): any;
        };
    }) | undefined>;
    /**
     * @description el-tooltip-content component instance
     */
    contentRef: vue.Ref<any, any>;
    /**
     * @description validate current focus event is trigger inside el-tooltip-content
     */
    isFocusInsideContent: typeof isFocusInsideContent;
    /**
     * @description update el-popper component instance
     */
    updatePopper: typeof updatePopper;
    /**
     * @description expose onOpen function to mange el-tooltip open state
     */
    onOpen: (event?: Event) => void;
    /**
     * @description expose onOpen function to mange el-tooltip open state
     */
    onClose: (event?: Event) => void;
    /**
     * @description expose hide function
     */
    hide: (event?: Event) => void;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly showArrow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
    readonly disabled: BooleanConstructor;
    readonly trigger: {
        readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    readonly triggerKeys: {
        readonly type: vue.PropType<string[]>;
        readonly default: () => string[];
    };
    readonly virtualRef: {
        readonly type: vue.PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
    readonly ariaLabel: {
        readonly type: StringConstructor;
    };
    readonly appendTo: {
        readonly type: vue.PropType<string | HTMLElement>;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly rawContent: BooleanConstructor;
    readonly persistent: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly style: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    readonly enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly pure: {
        type: BooleanConstructor;
    };
    readonly focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly zIndex: {
        type: NumberConstructor;
    };
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly "onUpdate:visible": {
        readonly type: vue.PropType<(val: boolean) => void>;
    };
    readonly role: {
        readonly type: vue.PropType<typeof roleTypes[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
}>> & Readonly<{}>, {
    readonly disabled: boolean;
    readonly showAfter: number;
    readonly hideAfter: number;
    readonly autoClose: number;
    readonly open: boolean;
    readonly placement: Placement;
    readonly strategy: "fixed" | "absolute";
    readonly effect: string;
    readonly content: string;
    readonly offset: number;
    readonly arrowOffset: number;
    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
    readonly boundariesPadding: number;
    readonly fallbackPlacements: Placement[];
    readonly gpuAcceleration: boolean;
    readonly popperOptions: Partial<Options>;
    readonly visible: boolean | null;
    readonly enterable: boolean;
    readonly pure: boolean;
    readonly focusOnShow: boolean;
    readonly trapping: boolean;
    readonly stopPopperMouseEvent: boolean;
    readonly virtualTriggering: boolean;
    readonly trigger: Arrayable<TooltipTriggerType>;
    readonly triggerKeys: string[];
    readonly rawContent: boolean;
    readonly persistent: boolean;
    readonly teleported: boolean;
    readonly showArrow: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
declare const _default$2: __VLS_WithTemplateSlots$2<typeof __VLS_component$2, __VLS_TemplateResult$2["slots"]>;

type __VLS_WithTemplateSlots$2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

interface ElTooltipInjectionContext {
    controlled: Ref<boolean>;
    id: Ref<string>;
    open: Ref<boolean>;
    trigger: Ref<Arrayable<TooltipTriggerType>>;
    onOpen: (e?: Event) => void;
    onClose: (e?: Event) => void;
    onToggle: (e: Event) => void;
    onShow: () => void;
    onHide: () => void;
    onBeforeShow: () => void;
    onBeforeHide: () => void;
    updatePopper: () => void;
}
declare const TOOLTIP_INJECTION_KEY: InjectionKey<ElTooltipInjectionContext>;

declare function __VLS_template$1(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {
        contentRef: ({
            $: vue.ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                placement: Placement;
                strategy: "fixed" | "absolute";
                effect: string;
                offset: number;
                boundariesPadding: number;
                fallbackPlacements: Placement[];
                gpuAcceleration: boolean;
                popperOptions: Partial<Options>;
                visible: boolean;
                enterable: boolean;
                pure: boolean;
                focusOnShow: boolean;
                trapping: boolean;
                stopPopperMouseEvent: boolean;
                virtualTriggering: boolean;
            }> & Omit<{
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly offset: number;
                readonly boundariesPadding: number;
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly ariaLabel?: string | undefined;
                readonly zIndex?: number | undefined;
                readonly style?: vue.StyleValue;
                readonly id?: string | undefined;
                readonly fallbackPlacements?: Placement[] | undefined;
                readonly className?: (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
                readonly popperClass?: (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
                readonly popperStyle?: vue.StyleValue;
                readonly referenceEl?: HTMLElement | undefined;
                readonly triggerTargetEl?: HTMLElement | undefined;
                readonly onClose?: (() => any) | undefined;
                readonly onBlur?: (() => any) | undefined;
                readonly onFocus?: (() => any) | undefined;
                readonly onMouseenter?: ((evt: MouseEvent) => any) | undefined;
                readonly onMouseleave?: ((evt: MouseEvent) => any) | undefined;
            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "placement" | "strategy" | "effect" | "offset" | "boundariesPadding" | "fallbackPlacements" | "gpuAcceleration" | "popperOptions" | "visible" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "virtualTriggering">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: vue.Slot<any> | undefined;
            }>;
            $root: vue.ComponentPublicInstance | null;
            $parent: vue.ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "close") => void) & ((event: "blur") => void) & ((event: "focus") => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "mouseleave", evt: MouseEvent) => void);
            $el: any;
            $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                ariaLabel: {
                    readonly type: StringConstructor;
                };
                id: {
                    type: StringConstructor;
                };
                style: {
                    type: vue.PropType<vue.StyleValue>;
                };
                className: {
                    type: vue.PropType<string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | any)[])[])[])[])[])[])[])[])[])[])[]>;
                };
                effect: {
                    type: vue.PropType<PopperEffect | string>;
                    default: string;
                };
                visible: {
                    type: BooleanConstructor;
                };
                enterable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                pure: {
                    type: BooleanConstructor;
                };
                focusOnShow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                trapping: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popperClass: {
                    type: vue.PropType<string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | any)[])[])[])[])[])[])[])[])[])[])[]>;
                };
                popperStyle: {
                    type: vue.PropType<vue.StyleValue>;
                };
                referenceEl: {
                    type: vue.PropType<HTMLElement>;
                };
                triggerTargetEl: {
                    type: vue.PropType<HTMLElement>;
                };
                stopPopperMouseEvent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                virtualTriggering: {
                    type: BooleanConstructor;
                };
                zIndex: {
                    type: NumberConstructor;
                };
                boundariesPadding: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                fallbackPlacements: {
                    readonly type: vue.PropType<Placement[]>;
                    readonly default: undefined;
                };
                gpuAcceleration: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                offset: {
                    readonly type: NumberConstructor;
                    readonly default: 12;
                };
                placement: {
                    readonly type: vue.PropType<Placement>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "bottom";
                };
                popperOptions: {
                    readonly type: vue.PropType<Partial<Options>>;
                    readonly default: () => {};
                };
                strategy: {
                    readonly type: vue.PropType<"fixed" | "absolute">;
                    readonly validator: (val: string) => boolean;
                    readonly default: "absolute";
                };
            }>> & Readonly<{
                onClose?: (() => any) | undefined;
                onBlur?: (() => any) | undefined;
                onFocus?: (() => any) | undefined;
                onMouseenter?: ((evt: MouseEvent) => any) | undefined;
                onMouseleave?: ((evt: MouseEvent) => any) | undefined;
            }>, {
                popperContentRef: vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
                popperInstanceRef: vue.ComputedRef<Instance | undefined>;
                updatePopper: (shouldUpdateZIndex?: boolean) => void;
                contentStyle: vue.ComputedRef<vue.StyleValue[]>;
            }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
                close: () => void;
                blur: () => void;
                focus: () => void;
                mouseenter: (evt: MouseEvent) => void;
                mouseleave: (evt: MouseEvent) => void;
            }, string, {
                placement: Placement;
                strategy: "fixed" | "absolute";
                effect: string;
                offset: number;
                boundariesPadding: number;
                fallbackPlacements: Placement[];
                gpuAcceleration: boolean;
                popperOptions: Partial<Options>;
                visible: boolean;
                enterable: boolean;
                pure: boolean;
                focusOnShow: boolean;
                trapping: boolean;
                stopPopperMouseEvent: boolean;
                virtualTriggering: boolean;
            }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof vue.nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
        } & Readonly<{
            placement: Placement;
            strategy: "fixed" | "absolute";
            effect: string;
            offset: number;
            boundariesPadding: number;
            fallbackPlacements: Placement[];
            gpuAcceleration: boolean;
            popperOptions: Partial<Options>;
            visible: boolean;
            enterable: boolean;
            pure: boolean;
            focusOnShow: boolean;
            trapping: boolean;
            stopPopperMouseEvent: boolean;
            virtualTriggering: boolean;
        }> & Omit<Readonly<vue.ExtractPropTypes<{
            ariaLabel: {
                readonly type: StringConstructor;
            };
            id: {
                type: StringConstructor;
            };
            style: {
                type: vue.PropType<vue.StyleValue>;
            };
            className: {
                type: vue.PropType<string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]>;
            };
            effect: {
                type: vue.PropType<PopperEffect | string>;
                default: string;
            };
            visible: {
                type: BooleanConstructor;
            };
            enterable: {
                type: BooleanConstructor;
                default: boolean;
            };
            pure: {
                type: BooleanConstructor;
            };
            focusOnShow: {
                type: BooleanConstructor;
                default: boolean;
            };
            trapping: {
                type: BooleanConstructor;
                default: boolean;
            };
            popperClass: {
                type: vue.PropType<string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]>;
            };
            popperStyle: {
                type: vue.PropType<vue.StyleValue>;
            };
            referenceEl: {
                type: vue.PropType<HTMLElement>;
            };
            triggerTargetEl: {
                type: vue.PropType<HTMLElement>;
            };
            stopPopperMouseEvent: {
                type: BooleanConstructor;
                default: boolean;
            };
            virtualTriggering: {
                type: BooleanConstructor;
            };
            zIndex: {
                type: NumberConstructor;
            };
            boundariesPadding: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            fallbackPlacements: {
                readonly type: vue.PropType<Placement[]>;
                readonly default: undefined;
            };
            gpuAcceleration: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            offset: {
                readonly type: NumberConstructor;
                readonly default: 12;
            };
            placement: {
                readonly type: vue.PropType<Placement>;
                readonly validator: (val: string) => boolean;
                readonly default: "bottom";
            };
            popperOptions: {
                readonly type: vue.PropType<Partial<Options>>;
                readonly default: () => {};
            };
            strategy: {
                readonly type: vue.PropType<"fixed" | "absolute">;
                readonly validator: (val: string) => boolean;
                readonly default: "absolute";
            };
        }>> & Readonly<{
            onClose?: (() => any) | undefined;
            onBlur?: (() => any) | undefined;
            onFocus?: (() => any) | undefined;
            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
        }>, "popperInstanceRef" | "contentStyle" | "popperContentRef" | "updatePopper" | ("placement" | "strategy" | "effect" | "offset" | "boundariesPadding" | "fallbackPlacements" | "gpuAcceleration" | "popperOptions" | "visible" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "virtualTriggering")> & vue.ShallowUnwrapRef<{
            popperContentRef: vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
            popperInstanceRef: vue.ComputedRef<Instance | undefined>;
            updatePopper: (shouldUpdateZIndex?: boolean) => void;
            contentStyle: vue.ComputedRef<vue.StyleValue[]>;
        }> & {} & vue.ComponentCustomProperties & {} & {
            $slots: {
                default?(_: {}): any;
            };
        }) | null;
    };
    attrs: Partial<{}>;
};
type __VLS_TemplateResult$1 = ReturnType<typeof __VLS_template$1>;
declare const __VLS_component$1: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly ariaLabel: {
        readonly type: StringConstructor;
    };
    readonly appendTo: {
        readonly type: vue.PropType<string | HTMLElement>;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly rawContent: BooleanConstructor;
    readonly persistent: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly disabled: BooleanConstructor;
    readonly id: {
        type: StringConstructor;
    };
    readonly style: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    readonly enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly pure: {
        type: BooleanConstructor;
    };
    readonly focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly virtualTriggering: {
        type: BooleanConstructor;
    };
    readonly zIndex: {
        type: NumberConstructor;
    };
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
}>, {
    /**
     * @description el-popper-content component instance
     */
    contentRef: vue.Ref<any, any>;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly ariaLabel: {
        readonly type: StringConstructor;
    };
    readonly appendTo: {
        readonly type: vue.PropType<string | HTMLElement>;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly rawContent: BooleanConstructor;
    readonly persistent: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly disabled: BooleanConstructor;
    readonly id: {
        type: StringConstructor;
    };
    readonly style: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    readonly enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly pure: {
        type: BooleanConstructor;
    };
    readonly focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly virtualTriggering: {
        type: BooleanConstructor;
    };
    readonly zIndex: {
        type: NumberConstructor;
    };
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
}>> & Readonly<{}>, {
    readonly disabled: boolean;
    readonly showAfter: number;
    readonly hideAfter: number;
    readonly autoClose: number;
    readonly placement: Placement;
    readonly strategy: "fixed" | "absolute";
    readonly effect: string;
    readonly content: string;
    readonly offset: number;
    readonly boundariesPadding: number;
    readonly fallbackPlacements: Placement[];
    readonly gpuAcceleration: boolean;
    readonly popperOptions: Partial<Options>;
    readonly visible: boolean | null;
    readonly enterable: boolean;
    readonly pure: boolean;
    readonly focusOnShow: boolean;
    readonly trapping: boolean;
    readonly stopPopperMouseEvent: boolean;
    readonly virtualTriggering: boolean;
    readonly rawContent: boolean;
    readonly persistent: boolean;
    readonly teleported: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
declare const _default$1: __VLS_WithTemplateSlots$1<typeof __VLS_component$1, __VLS_TemplateResult$1["slots"]>;

type __VLS_WithTemplateSlots$1<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const useTooltipContentProps: {
    readonly ariaLabel: {
        readonly type: StringConstructor;
    };
    /**
     * @description which element the tooltip CONTENT appends to
     */
    readonly appendTo: {
        readonly type: PropType<string | HTMLElement>;
    };
    /**
     * @description display content, can be overridden by `slot#content`
     */
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    /**
     * @description whether `content` is treated as HTML string
     */
    readonly rawContent: BooleanConstructor;
    /**
     * @description when tooltip inactive and `persistent` is `false` , popconfirm will be destroyed
     */
    readonly persistent: BooleanConstructor;
    /**
     * @description visibility of Tooltip
     */
    readonly visible: {
        readonly type: PropType<boolean | null>;
        readonly default: null;
    };
    /**
     * @description animation name
     */
    readonly transition: StringConstructor;
    /**
     * @description whether tooltip content is teleported, if `true` it will be teleported to where `append-to` sets
     */
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * @description whether Tooltip is disabled
     */
    readonly disabled: BooleanConstructor;
    readonly id: {
        type: StringConstructor;
    };
    readonly style: {
        type: PropType<vue.StyleValue>;
    };
    readonly className: {
        type: PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly effect: {
        type: PropType<PopperEffect | string>;
        default: string;
    };
    readonly enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly pure: {
        type: BooleanConstructor;
    };
    readonly focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly popperClass: {
        type: PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly popperStyle: {
        type: PropType<vue.StyleValue>;
    };
    readonly referenceEl: {
        type: PropType<HTMLElement>;
    };
    readonly triggerTargetEl: {
        type: PropType<HTMLElement>;
    };
    readonly stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly virtualTriggering: {
        type: BooleanConstructor;
    };
    readonly zIndex: {
        type: NumberConstructor;
    };
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    readonly placement: {
        readonly type: PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    readonly popperOptions: {
        readonly type: PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
};
type ElTooltipContentProps = ExtractPropTypes<typeof useTooltipContentProps>;
type TooltipContentInstance = InstanceType<typeof _default$1>;

declare global {
    interface PointerLockOptions {
        unadjustedMovement?: boolean;
    }
    interface Element {
        requestPointerLock(options?: PointerLockOptions): Promise<void> | void;
    }
}

declare const _prop: {
    readonly type: PropType<boolean | null>;
    readonly default: null;
};
declare const _event: {
    readonly type: PropType<(val: boolean) => void>;
};
type UseModelTogglePropsRaw<T extends string> = {
    [K in T]: typeof _prop;
} & {
    [K in `onUpdate:${T}`]: typeof _event;
};
interface ModelToggleParams {
    indicator: Ref<boolean>;
    toggleReason?: Ref<Event | undefined>;
    shouldHideWhenRouteChanges?: Ref<boolean>;
    shouldProceed?: () => boolean;
    onShow?: (event?: Event) => void;
    onHide?: (event?: Event) => void;
}

declare const useTooltipModelToggleProps: UseModelTogglePropsRaw<"visible">;
declare const useTooltipModelToggleEmits: "update:visible"[];
declare const useTooltipModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
    hide: (event?: Event) => void;
    show: (event?: Event) => void;
    toggle: () => void;
    hasUpdateHandler: vue.ComputedRef<boolean>;
};
declare const useTooltipProps: {
    /**
     * @description whether the tooltip content has an arrow
     */
    readonly showArrow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly arrowOffset: {
        readonly type: NumberConstructor;
        readonly default: 5;
    };
    readonly disabled: BooleanConstructor;
    readonly trigger: {
        readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    readonly triggerKeys: {
        readonly type: vue.PropType<string[]>;
        readonly default: () => string[];
    };
    readonly virtualRef: {
        readonly type: vue.PropType<Measurable>;
    };
    readonly virtualTriggering: {
        readonly type: BooleanConstructor;
    };
    readonly onMouseenter: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onMouseleave: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onClick: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onKeydown: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onFocus: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onBlur: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly onContextmenu: {
        readonly type: vue.PropType<(e: Event) => void>;
    };
    readonly id: {
        readonly type: StringConstructor;
    };
    readonly open: {
        readonly type: BooleanConstructor;
    };
    readonly ariaLabel: {
        readonly type: StringConstructor;
    };
    readonly appendTo: {
        readonly type: vue.PropType<string | HTMLElement>;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly rawContent: BooleanConstructor;
    readonly persistent: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly style: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly className: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly effect: {
        type: vue.PropType<PopperEffect | string>;
        default: string;
    };
    readonly enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly pure: {
        type: BooleanConstructor;
    };
    readonly focusOnShow: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly trapping: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly referenceEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly triggerTargetEl: {
        type: vue.PropType<HTMLElement>;
    };
    readonly stopPopperMouseEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    readonly zIndex: {
        type: NumberConstructor;
    };
    readonly boundariesPadding: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly fallbackPlacements: {
        readonly type: vue.PropType<Placement[]>;
        readonly default: undefined;
    };
    readonly gpuAcceleration: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: 12;
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly validator: (val: string) => boolean;
        readonly default: "bottom";
    };
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly strategy: {
        readonly type: vue.PropType<"fixed" | "absolute">;
        readonly validator: (val: string) => boolean;
        readonly default: "absolute";
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly "onUpdate:visible": {
        readonly type: vue.PropType<(val: boolean) => void>;
    };
    readonly role: {
        readonly type: vue.PropType<typeof roleTypes[number]>;
        readonly validator: (val: string) => boolean;
        readonly default: "tooltip";
    };
};
declare const tooltipEmits: string[];
type ElTooltipProps = ExtractPropTypes<typeof useTooltipProps>;
type TooltipInstance = InstanceType<typeof _default$2>;

declare function hide(): void;
declare function __VLS_template(): {
    slots: {
        reference?(_: {}): any;
        default?(_: {}): any;
    };
    refs: {
        tooltipRef: ({
            $: vue.ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                readonly disabled: boolean;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: number;
                readonly open: boolean;
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly content: string;
                readonly offset: number;
                readonly arrowOffset: number;
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                readonly boundariesPadding: number;
                readonly fallbackPlacements: Placement[];
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean | null;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly trigger: Arrayable<TooltipTriggerType>;
                readonly triggerKeys: string[];
                readonly rawContent: boolean;
                readonly persistent: boolean;
                readonly teleported: boolean;
                readonly showArrow: boolean;
            }> & Omit<{
                readonly disabled: boolean;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: number;
                readonly open: boolean;
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly content: string;
                readonly offset: number;
                readonly arrowOffset: number;
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                readonly boundariesPadding: number;
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean | null;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly trigger: Arrayable<TooltipTriggerType>;
                readonly triggerKeys: string[];
                readonly rawContent: boolean;
                readonly persistent: boolean;
                readonly teleported: boolean;
                readonly showArrow: boolean;
                readonly ariaLabel?: string | undefined;
                readonly transition?: string | undefined;
                readonly zIndex?: number | undefined;
                readonly style?: vue.StyleValue;
                readonly id?: string | undefined;
                readonly onFocus?: ((e: Event) => void) | undefined;
                readonly onBlur?: ((e: Event) => void) | undefined;
                readonly onKeydown?: ((e: Event) => void) | undefined;
                readonly onClick?: ((e: Event) => void) | undefined;
                readonly onContextmenu?: ((e: Event) => void) | undefined;
                readonly onMouseenter?: ((e: Event) => void) | undefined;
                readonly onMouseleave?: ((e: Event) => void) | undefined;
                readonly fallbackPlacements?: Placement[] | undefined;
                readonly className?: (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
                readonly popperClass?: (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
                readonly popperStyle?: vue.StyleValue;
                readonly referenceEl?: HTMLElement | undefined;
                readonly triggerTargetEl?: HTMLElement | undefined;
                readonly virtualRef?: Measurable | undefined;
                readonly appendTo?: string | HTMLElement | undefined;
                readonly "onUpdate:visible"?: ((val: boolean) => void) | undefined;
            } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "disabled" | "showAfter" | "hideAfter" | "autoClose" | "open" | "placement" | "strategy" | "effect" | "content" | "offset" | "arrowOffset" | "role" | "boundariesPadding" | "fallbackPlacements" | "gpuAcceleration" | "popperOptions" | "visible" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "virtualTriggering" | "trigger" | "triggerKeys" | "rawContent" | "persistent" | "teleported" | "showArrow">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: vue.Slot<any> | undefined;
            }>;
            $root: vue.ComponentPublicInstance | null;
            $parent: vue.ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                readonly showArrow: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly arrowOffset: {
                    readonly type: NumberConstructor;
                    readonly default: 5;
                };
                readonly disabled: BooleanConstructor;
                readonly trigger: {
                    readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
                    readonly default: "hover";
                };
                readonly triggerKeys: {
                    readonly type: vue.PropType<string[]>;
                    readonly default: () => string[];
                };
                readonly virtualRef: {
                    readonly type: vue.PropType<Measurable>;
                };
                readonly virtualTriggering: {
                    readonly type: BooleanConstructor;
                };
                readonly onMouseenter: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly onMouseleave: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly onClick: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly onKeydown: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly onFocus: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly onBlur: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly onContextmenu: {
                    readonly type: vue.PropType<(e: Event) => void>;
                };
                readonly id: {
                    readonly type: StringConstructor;
                };
                readonly open: {
                    readonly type: BooleanConstructor;
                };
                readonly ariaLabel: {
                    readonly type: StringConstructor;
                };
                readonly appendTo: {
                    readonly type: vue.PropType<string | HTMLElement>;
                };
                readonly content: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly rawContent: BooleanConstructor;
                readonly persistent: BooleanConstructor;
                readonly visible: {
                    readonly type: vue.PropType<boolean | null>;
                    readonly default: null;
                };
                readonly transition: StringConstructor;
                readonly teleported: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly style: {
                    type: vue.PropType<vue.StyleValue>;
                };
                readonly className: {
                    type: vue.PropType<string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | any)[])[])[])[])[])[])[])[])[])[])[]>;
                };
                readonly effect: {
                    type: vue.PropType<PopperEffect | string>;
                    default: string;
                };
                readonly enterable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly pure: {
                    type: BooleanConstructor;
                };
                readonly focusOnShow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly trapping: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly popperClass: {
                    type: vue.PropType<string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | any)[])[])[])[])[])[])[])[])[])[])[]>;
                };
                readonly popperStyle: {
                    type: vue.PropType<vue.StyleValue>;
                };
                readonly referenceEl: {
                    type: vue.PropType<HTMLElement>;
                };
                readonly triggerTargetEl: {
                    type: vue.PropType<HTMLElement>;
                };
                readonly stopPopperMouseEvent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                readonly zIndex: {
                    type: NumberConstructor;
                };
                readonly boundariesPadding: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly fallbackPlacements: {
                    readonly type: vue.PropType<Placement[]>;
                    readonly default: undefined;
                };
                readonly gpuAcceleration: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly offset: {
                    readonly type: NumberConstructor;
                    readonly default: 12;
                };
                readonly placement: {
                    readonly type: vue.PropType<Placement>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "bottom";
                };
                readonly popperOptions: {
                    readonly type: vue.PropType<Partial<Options>>;
                    readonly default: () => {};
                };
                readonly strategy: {
                    readonly type: vue.PropType<"fixed" | "absolute">;
                    readonly validator: (val: string) => boolean;
                    readonly default: "absolute";
                };
                readonly showAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly hideAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 200;
                };
                readonly autoClose: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly "onUpdate:visible": {
                    readonly type: vue.PropType<(val: boolean) => void>;
                };
                readonly role: {
                    readonly type: vue.PropType<typeof roleTypes[number]>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "tooltip";
                };
            }>> & Readonly<{}>, {
                popperRef: vue.Ref<({
                    $: vue.ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                    }> & Omit<{
                        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    };
                    $slots: Readonly<{
                        [name: string]: vue.Slot<any> | undefined;
                    }>;
                    $root: vue.ComponentPublicInstance | null;
                    $parent: vue.ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: (event: string, ...args: any[]) => void;
                    $el: any;
                    $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                        readonly role: {
                            readonly type: vue.PropType<typeof roleTypes[number]>;
                            readonly validator: (val: string) => boolean;
                            readonly default: "tooltip";
                        };
                    }>> & Readonly<{}>, {
                        triggerRef: vue.Ref<Measurable | undefined>;
                        contentRef: vue.Ref<HTMLElement | undefined>;
                        popperInstanceRef: vue.Ref<Instance | undefined>;
                        referenceRef: vue.Ref<Measurable | undefined>;
                        role: vue.ComputedRef<string>;
                    }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                        renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof vue.nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
                } & Readonly<{
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                }> & Omit<Readonly<vue.ExtractPropTypes<{
                    readonly role: {
                        readonly type: vue.PropType<typeof roleTypes[number]>;
                        readonly validator: (val: string) => boolean;
                        readonly default: "tooltip";
                    };
                }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
                    triggerRef: vue.Ref<Measurable | undefined>;
                    contentRef: vue.Ref<HTMLElement | undefined>;
                    popperInstanceRef: vue.Ref<Instance | undefined>;
                    referenceRef: vue.Ref<Measurable | undefined>;
                    role: vue.ComputedRef<string>;
                }> & {} & vue.ComponentCustomProperties & {} & {
                    $slots: {
                        default?(_: {}): any;
                    };
                }) | undefined, ({
                    $: vue.ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                    }> & Omit<{
                        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    };
                    $slots: Readonly<{
                        [name: string]: vue.Slot<any> | undefined;
                    }>;
                    $root: vue.ComponentPublicInstance | null;
                    $parent: vue.ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: (event: string, ...args: any[]) => void;
                    $el: any;
                    $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                        readonly role: {
                            readonly type: vue.PropType<typeof roleTypes[number]>;
                            readonly validator: (val: string) => boolean;
                            readonly default: "tooltip";
                        };
                    }>> & Readonly<{}>, {
                        triggerRef: vue.Ref<Measurable | undefined>;
                        contentRef: vue.Ref<HTMLElement | undefined>;
                        popperInstanceRef: vue.Ref<Instance | undefined>;
                        referenceRef: vue.Ref<Measurable | undefined>;
                        role: vue.ComputedRef<string>;
                    }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                    }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                        renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof vue.nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
                } & Readonly<{
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                }> & Omit<Readonly<vue.ExtractPropTypes<{
                    readonly role: {
                        readonly type: vue.PropType<typeof roleTypes[number]>;
                        readonly validator: (val: string) => boolean;
                        readonly default: "tooltip";
                    };
                }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
                    triggerRef: vue.Ref<Measurable | undefined>;
                    contentRef: vue.Ref<HTMLElement | undefined>;
                    popperInstanceRef: vue.Ref<Instance | undefined>;
                    referenceRef: vue.Ref<Measurable | undefined>;
                    role: vue.ComputedRef<string>;
                }> & {} & vue.ComponentCustomProperties & {} & {
                    $slots: {
                        default?(_: {}): any;
                    };
                }) | undefined>;
                contentRef: vue.Ref<any, any>;
                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                updatePopper: () => void;
                onOpen: (event?: Event) => void;
                onClose: (event?: Event) => void;
                hide: (event?: Event) => void;
            }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                readonly disabled: boolean;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: number;
                readonly open: boolean;
                readonly placement: Placement;
                readonly strategy: "fixed" | "absolute";
                readonly effect: string;
                readonly content: string;
                readonly offset: number;
                readonly arrowOffset: number;
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                readonly boundariesPadding: number;
                readonly fallbackPlacements: Placement[];
                readonly gpuAcceleration: boolean;
                readonly popperOptions: Partial<Options>;
                readonly visible: boolean | null;
                readonly enterable: boolean;
                readonly pure: boolean;
                readonly focusOnShow: boolean;
                readonly trapping: boolean;
                readonly stopPopperMouseEvent: boolean;
                readonly virtualTriggering: boolean;
                readonly trigger: Arrayable<TooltipTriggerType>;
                readonly triggerKeys: string[];
                readonly rawContent: boolean;
                readonly persistent: boolean;
                readonly teleported: boolean;
                readonly showArrow: boolean;
            }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof vue.nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
        } & Readonly<{
            readonly disabled: boolean;
            readonly showAfter: number;
            readonly hideAfter: number;
            readonly autoClose: number;
            readonly open: boolean;
            readonly placement: Placement;
            readonly strategy: "fixed" | "absolute";
            readonly effect: string;
            readonly content: string;
            readonly offset: number;
            readonly arrowOffset: number;
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
            readonly boundariesPadding: number;
            readonly fallbackPlacements: Placement[];
            readonly gpuAcceleration: boolean;
            readonly popperOptions: Partial<Options>;
            readonly visible: boolean | null;
            readonly enterable: boolean;
            readonly pure: boolean;
            readonly focusOnShow: boolean;
            readonly trapping: boolean;
            readonly stopPopperMouseEvent: boolean;
            readonly virtualTriggering: boolean;
            readonly trigger: Arrayable<TooltipTriggerType>;
            readonly triggerKeys: string[];
            readonly rawContent: boolean;
            readonly persistent: boolean;
            readonly teleported: boolean;
            readonly showArrow: boolean;
        }> & Omit<Readonly<vue.ExtractPropTypes<{
            readonly showArrow: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly arrowOffset: {
                readonly type: NumberConstructor;
                readonly default: 5;
            };
            readonly disabled: BooleanConstructor;
            readonly trigger: {
                readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
                readonly default: "hover";
            };
            readonly triggerKeys: {
                readonly type: vue.PropType<string[]>;
                readonly default: () => string[];
            };
            readonly virtualRef: {
                readonly type: vue.PropType<Measurable>;
            };
            readonly virtualTriggering: {
                readonly type: BooleanConstructor;
            };
            readonly onMouseenter: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly onMouseleave: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly onClick: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly onKeydown: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly onFocus: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly onBlur: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly onContextmenu: {
                readonly type: vue.PropType<(e: Event) => void>;
            };
            readonly id: {
                readonly type: StringConstructor;
            };
            readonly open: {
                readonly type: BooleanConstructor;
            };
            readonly ariaLabel: {
                readonly type: StringConstructor;
            };
            readonly appendTo: {
                readonly type: vue.PropType<string | HTMLElement>;
            };
            readonly content: {
                readonly type: StringConstructor;
                readonly default: "";
            };
            readonly rawContent: BooleanConstructor;
            readonly persistent: BooleanConstructor;
            readonly visible: {
                readonly type: vue.PropType<boolean | null>;
                readonly default: null;
            };
            readonly transition: StringConstructor;
            readonly teleported: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly style: {
                type: vue.PropType<vue.StyleValue>;
            };
            readonly className: {
                type: vue.PropType<string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]>;
            };
            readonly effect: {
                type: vue.PropType<PopperEffect | string>;
                default: string;
            };
            readonly enterable: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly pure: {
                type: BooleanConstructor;
            };
            readonly focusOnShow: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly trapping: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly popperClass: {
                type: vue.PropType<string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | any)[])[])[])[])[])[])[])[])[])[])[]>;
            };
            readonly popperStyle: {
                type: vue.PropType<vue.StyleValue>;
            };
            readonly referenceEl: {
                type: vue.PropType<HTMLElement>;
            };
            readonly triggerTargetEl: {
                type: vue.PropType<HTMLElement>;
            };
            readonly stopPopperMouseEvent: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly zIndex: {
                type: NumberConstructor;
            };
            readonly boundariesPadding: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly fallbackPlacements: {
                readonly type: vue.PropType<Placement[]>;
                readonly default: undefined;
            };
            readonly gpuAcceleration: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly offset: {
                readonly type: NumberConstructor;
                readonly default: 12;
            };
            readonly placement: {
                readonly type: vue.PropType<Placement>;
                readonly validator: (val: string) => boolean;
                readonly default: "bottom";
            };
            readonly popperOptions: {
                readonly type: vue.PropType<Partial<Options>>;
                readonly default: () => {};
            };
            readonly strategy: {
                readonly type: vue.PropType<"fixed" | "absolute">;
                readonly validator: (val: string) => boolean;
                readonly default: "absolute";
            };
            readonly showAfter: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly hideAfter: {
                readonly type: NumberConstructor;
                readonly default: 200;
            };
            readonly autoClose: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly "onUpdate:visible": {
                readonly type: vue.PropType<(val: boolean) => void>;
            };
            readonly role: {
                readonly type: vue.PropType<typeof roleTypes[number]>;
                readonly validator: (val: string) => boolean;
                readonly default: "tooltip";
            };
        }>> & Readonly<{}>, "contentRef" | "onClose" | "hide" | "updatePopper" | "onOpen" | "popperRef" | "isFocusInsideContent" | ("disabled" | "showAfter" | "hideAfter" | "autoClose" | "open" | "placement" | "strategy" | "effect" | "content" | "offset" | "arrowOffset" | "role" | "boundariesPadding" | "fallbackPlacements" | "gpuAcceleration" | "popperOptions" | "visible" | "enterable" | "pure" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "virtualTriggering" | "trigger" | "triggerKeys" | "rawContent" | "persistent" | "teleported" | "showArrow")> & vue.ShallowUnwrapRef<{
            popperRef: vue.Ref<({
                $: vue.ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                }> & Omit<{
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                };
                $slots: Readonly<{
                    [name: string]: vue.Slot<any> | undefined;
                }>;
                $root: vue.ComponentPublicInstance | null;
                $parent: vue.ComponentPublicInstance | null;
                $host: Element | null;
                $emit: (event: string, ...args: any[]) => void;
                $el: any;
                $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                    readonly role: {
                        readonly type: vue.PropType<typeof roleTypes[number]>;
                        readonly validator: (val: string) => boolean;
                        readonly default: "tooltip";
                    };
                }>> & Readonly<{}>, {
                    triggerRef: vue.Ref<Measurable | undefined>;
                    contentRef: vue.Ref<HTMLElement | undefined>;
                    popperInstanceRef: vue.Ref<Instance | undefined>;
                    referenceRef: vue.Ref<Measurable | undefined>;
                    role: vue.ComputedRef<string>;
                }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                    renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof vue.nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
            } & Readonly<{
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
            }> & Omit<Readonly<vue.ExtractPropTypes<{
                readonly role: {
                    readonly type: vue.PropType<typeof roleTypes[number]>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "tooltip";
                };
            }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
                triggerRef: vue.Ref<Measurable | undefined>;
                contentRef: vue.Ref<HTMLElement | undefined>;
                popperInstanceRef: vue.Ref<Instance | undefined>;
                referenceRef: vue.Ref<Measurable | undefined>;
                role: vue.ComputedRef<string>;
            }> & {} & vue.ComponentCustomProperties & {} & {
                $slots: {
                    default?(_: {}): any;
                };
            }) | undefined, ({
                $: vue.ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                }> & Omit<{
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                };
                $slots: Readonly<{
                    [name: string]: vue.Slot<any> | undefined;
                }>;
                $root: vue.ComponentPublicInstance | null;
                $parent: vue.ComponentPublicInstance | null;
                $host: Element | null;
                $emit: (event: string, ...args: any[]) => void;
                $el: any;
                $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
                    readonly role: {
                        readonly type: vue.PropType<typeof roleTypes[number]>;
                        readonly validator: (val: string) => boolean;
                        readonly default: "tooltip";
                    };
                }>> & Readonly<{}>, {
                    triggerRef: vue.Ref<Measurable | undefined>;
                    contentRef: vue.Ref<HTMLElement | undefined>;
                    popperInstanceRef: vue.Ref<Instance | undefined>;
                    referenceRef: vue.Ref<Measurable | undefined>;
                    role: vue.ComputedRef<string>;
                }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
                    readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
                }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                    renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof vue.nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
            } & Readonly<{
                readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
            }> & Omit<Readonly<vue.ExtractPropTypes<{
                readonly role: {
                    readonly type: vue.PropType<typeof roleTypes[number]>;
                    readonly validator: (val: string) => boolean;
                    readonly default: "tooltip";
                };
            }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
                triggerRef: vue.Ref<Measurable | undefined>;
                contentRef: vue.Ref<HTMLElement | undefined>;
                popperInstanceRef: vue.Ref<Instance | undefined>;
                referenceRef: vue.Ref<Measurable | undefined>;
                role: vue.ComputedRef<string>;
            }> & {} & vue.ComponentCustomProperties & {} & {
                $slots: {
                    default?(_: {}): any;
                };
            }) | undefined>;
            contentRef: vue.Ref<any, any>;
            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
            updatePopper: () => void;
            onOpen: (event?: Event) => void;
            onClose: (event?: Event) => void;
            hide: (event?: Event) => void;
        }> & {} & vue.ComponentCustomProperties & {} & {
            $slots: {
                default?(_: {}): any;
                content?(_: {}): any;
            };
        }) | null;
    };
    attrs: Partial<{}>;
};
type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
declare const __VLS_component: vue.DefineComponent<vue.ExtractPropTypes<{
    readonly trigger: {
        readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly default: "bottom";
    };
    readonly disabled: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly tabindex: {
        readonly type: vue.PropType<number | string>;
        readonly default: 0;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly enterable: {
        readonly default: true;
        readonly type: BooleanConstructor;
    };
    readonly effect: {
        readonly default: "light";
        readonly type: vue.PropType<PopperEffect | string>;
    };
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly title: StringConstructor;
    readonly width: {
        readonly type: vue.PropType<string | number>;
        readonly default: 150;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly showArrow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly persistent: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly 'onUpdate:visible': {
        readonly type: vue.PropType<(visible: boolean) => void>;
    };
}>, {
    /** @description popper ref */
    popperRef: vue.ComputedRef<({
        $: vue.ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }> & Omit<{
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "role">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: vue.Slot<any> | undefined;
        }>;
        $root: vue.ComponentPublicInstance | null;
        $parent: vue.ComponentPublicInstance | null;
        $host: Element | null;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
            readonly role: {
                readonly type: vue.PropType<typeof roleTypes[number]>;
                readonly validator: (val: string) => boolean;
                readonly default: "tooltip";
            };
        }>> & Readonly<{}>, {
            triggerRef: vue.Ref<Measurable | undefined>;
            contentRef: vue.Ref<HTMLElement | undefined>;
            popperInstanceRef: vue.Ref<Instance | undefined>;
            referenceRef: vue.Ref<Measurable | undefined>;
            role: vue.ComputedRef<string>;
        }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
            readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
        }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
            beforeCreate?: (() => void) | (() => void)[];
            created?: (() => void) | (() => void)[];
            beforeMount?: (() => void) | (() => void)[];
            mounted?: (() => void) | (() => void)[];
            beforeUpdate?: (() => void) | (() => void)[];
            updated?: (() => void) | (() => void)[];
            activated?: (() => void) | (() => void)[];
            deactivated?: (() => void) | (() => void)[];
            beforeDestroy?: (() => void) | (() => void)[];
            beforeUnmount?: (() => void) | (() => void)[];
            destroyed?: (() => void) | (() => void)[];
            unmounted?: (() => void) | (() => void)[];
            renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
            renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
            errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof vue.nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
    } & Readonly<{
        readonly role: "grid" | "dialog" | "menu" | "group" | "listbox" | "navigation" | "tooltip" | "tree";
    }> & Omit<Readonly<vue.ExtractPropTypes<{
        readonly role: {
            readonly type: vue.PropType<typeof roleTypes[number]>;
            readonly validator: (val: string) => boolean;
            readonly default: "tooltip";
        };
    }>> & Readonly<{}>, "role" | "triggerRef" | "contentRef" | "popperInstanceRef" | "referenceRef"> & vue.ShallowUnwrapRef<{
        triggerRef: vue.Ref<Measurable | undefined>;
        contentRef: vue.Ref<HTMLElement | undefined>;
        popperInstanceRef: vue.Ref<Instance | undefined>;
        referenceRef: vue.Ref<Measurable | undefined>;
        role: vue.ComputedRef<string>;
    }> & {} & vue.ComponentCustomProperties & {} & {
        $slots: {
            default?(_: {}): any;
        };
    }) | undefined>;
    /** @description hide popover */
    hide: typeof hide;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
    "after-leave": () => void;
    "before-enter": () => void;
    "after-enter": () => void;
    "before-leave": () => void;
    "update:visible": (value: boolean) => void;
}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    readonly trigger: {
        readonly type: vue.PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    readonly placement: {
        readonly type: vue.PropType<Placement>;
        readonly default: "bottom";
    };
    readonly disabled: BooleanConstructor;
    readonly visible: {
        readonly type: vue.PropType<boolean | null>;
        readonly default: null;
    };
    readonly transition: StringConstructor;
    readonly popperOptions: {
        readonly type: vue.PropType<Partial<Options>>;
        readonly default: () => {};
    };
    readonly tabindex: {
        readonly type: vue.PropType<number | string>;
        readonly default: 0;
    };
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    readonly popperStyle: {
        type: vue.PropType<vue.StyleValue>;
    };
    readonly popperClass: {
        type: vue.PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly enterable: {
        readonly default: true;
        readonly type: BooleanConstructor;
    };
    readonly effect: {
        readonly default: "light";
        readonly type: vue.PropType<PopperEffect | string>;
    };
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly title: StringConstructor;
    readonly width: {
        readonly type: vue.PropType<string | number>;
        readonly default: 150;
    };
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly showArrow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly persistent: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly 'onUpdate:visible': {
        readonly type: vue.PropType<(visible: boolean) => void>;
    };
}>> & Readonly<{
    "onAfter-leave"?: (() => any) | undefined;
    "onBefore-enter"?: (() => any) | undefined;
    "onAfter-enter"?: (() => any) | undefined;
    "onBefore-leave"?: (() => any) | undefined;
    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
}>, {
    readonly disabled: boolean;
    readonly showAfter: number;
    readonly hideAfter: number;
    readonly autoClose: number;
    readonly placement: Placement;
    readonly effect: string;
    readonly content: string;
    readonly offset: number;
    readonly width: string | number;
    readonly popperOptions: Partial<Options>;
    readonly visible: boolean | null;
    readonly enterable: boolean;
    readonly tabindex: string | number;
    readonly trigger: Arrayable<TooltipTriggerType>;
    readonly persistent: boolean;
    readonly teleported: boolean;
    readonly showArrow: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare const popoverProps: {
    /**
     * @description how the popover is triggered
     */
    readonly trigger: {
        readonly type: PropType<Arrayable<TooltipTriggerType>>;
        readonly default: "hover";
    };
    /**
     * @description popover placement
     */
    readonly placement: {
        readonly type: PropType<Placement>;
        readonly default: "bottom";
    };
    /**
     * @description whether Popover is disabled
     */
    readonly disabled: BooleanConstructor;
    /**
     * @description whether popover is visible
     */
    readonly visible: {
        readonly type: PropType<boolean | null>;
        readonly default: null;
    };
    /**
     * @description popover transition animation
     */
    readonly transition: StringConstructor;
    /**
     * @description parameters for [popper.js](https://popper.js.org/docs/v2/)
     */
    readonly popperOptions: {
        readonly type: PropType<Partial<Options>>;
        readonly default: () => {};
    };
    /**
     * @description [tabindex](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex) of Popover
     */
    readonly tabindex: {
        readonly type: PropType<number | string>;
        readonly default: 0;
    };
    /**
     * @description popover content, can be replaced with a default `slot`
     */
    readonly content: {
        readonly type: StringConstructor;
        readonly default: "";
    };
    /**
     * @description custom style for popover
     */
    readonly popperStyle: {
        type: PropType<vue.StyleValue>;
    };
    /**
     * @description custom class name for popover
     */
    readonly popperClass: {
        type: PropType<string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>;
    };
    readonly enterable: {
        readonly default: true;
        readonly type: BooleanConstructor;
    };
    /**
     * @description Tooltip theme, built-in theme: `dark` / `light`
     */
    readonly effect: {
        readonly default: "light";
        readonly type: PropType<PopperEffect | string>;
    };
    /**
     * @description whether popover dropdown is teleported to the body
     */
    readonly teleported: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * @description popover title
     */
    readonly title: StringConstructor;
    /**
     * @description popover width
     */
    readonly width: {
        readonly type: PropType<string | number>;
        readonly default: 150;
    };
    /**
     * @description popover offset
     */
    readonly offset: {
        readonly type: NumberConstructor;
        readonly default: undefined;
    };
    /**
     * @description delay of appearance, in millisecond
     */
    readonly showAfter: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    /**
     * @description delay of disappear, in millisecond
     */
    readonly hideAfter: {
        readonly type: NumberConstructor;
        readonly default: 200;
    };
    /**
     * @description timeout in milliseconds to hide tooltip
     */
    readonly autoClose: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    /**
     * @description whether a tooltip arrow is displayed or not. For more info, please refer to [ElPopper](https://github.com/element-plus/element-plus/tree/dev/packages/components/popper)
     */
    readonly showArrow: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    /**
     * @description when popover inactive and `persistent` is `false` , popover will be destroyed
     */
    readonly persistent: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly 'onUpdate:visible': {
        readonly type: PropType<(visible: boolean) => void>;
    };
};
type PopoverProps = ExtractPropTypes<typeof popoverProps>;
declare const popoverEmits: {
    'update:visible': (value: boolean) => boolean;
    'before-enter': () => boolean;
    'before-leave': () => boolean;
    'after-enter': () => boolean;
    'after-leave': () => boolean;
};
type PopoverEmits = typeof popoverEmits;
type PopoverInstance = InstanceType<typeof _default>;

export { type CreatePopperInstanceParams, Effect, _default as ElPopover, _default$5 as ElPopper, _default$6 as ElPopperArrow, type ElPopperArrowContent, type ElPopperArrowInstance, type ElPopperArrowTrigger, _default$4 as ElPopperContent, type ElPopperContentInjectionContext, type ElPopperInjectionContext, _default$3 as ElPopperTrigger, _default$2 as ElTooltip, type ElTooltipContentProps, type ElTooltipInjectionContext, type ElTooltipProps, type ElTooltipTriggerProps, type Instance, type Measurable, type Modifier, type Options, POPPER_CONTENT_INJECTION_KEY, POPPER_INJECTION_KEY, type Placement, type PopoverEmits, type PopoverInstance, type PopoverProps, type PopperArrowInstance, type PopperArrowProps, type PopperContentEmits, type PopperContentInstance, type PopperContentProps, type PopperCoreConfigProps, type PopperEffect, type PopperInstance, type PopperProps, type PopperTrigger, type PopperTriggerInstance, type PopperTriggerProps, type State, TOOLTIP_INJECTION_KEY, type TooltipContentInstance, type TooltipInstance, type TooltipTriggerType, type UsePopperArrowProps, type UsePopperContentProps, type UsePopperCoreConfigProps, type UsePopperProps, popoverEmits, popoverProps, popperArrowProps, popperContentEmits, popperContentProps, popperCoreConfigProps, popperProps, popperTriggerProps, roleTypes, tooltipEmits, usePopperArrowProps, usePopperContentEmits, usePopperContentProps, usePopperCoreConfigProps, usePopperProps, usePopperTriggerProps, useTooltipContentProps, useTooltipModelToggle, useTooltipModelToggleEmits, useTooltipModelToggleProps, useTooltipProps, useTooltipTriggerProps };