export declare const VsTooltip: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
    shift: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) & {}) | (() => boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) | ((new (...args: any[]) => (boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) & {}) | (() => boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>))[], unknown, unknown, boolean, boolean>;
    color: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "primary" | "success" | "danger" | "warn" | "dark" | "text" | "light" | "secondary" | "facebook" | "twitter" | "youtube" | "pinterest" | "linkedin" | "snapchat" | "whatsapp" | "tumblr" | "reddit" | "spotify" | "amazon" | "medium" | "vimeo" | "skype" | "dribbble" | "slack" | "yahoo" | "twitch" | "discord" | "telegram" | "google-plus" | "messenger", import("../..").Color>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    animation: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
    interactivity: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    appendTo: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    type: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "border" | "shadow" | "border-thick", unknown, string, boolean>;
    shape: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "default" | "circle" | "square", unknown, string, boolean>;
    effect: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "dark" | "light", unknown, string, boolean>;
    showArrow: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    loading: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    offset: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bottom: BooleanConstructor;
    left: BooleanConstructor;
    right: BooleanConstructor;
    top: BooleanConstructor;
    notHover: BooleanConstructor;
    shadow: BooleanConstructor;
    border: BooleanConstructor;
    borderThick: BooleanConstructor;
    square: BooleanConstructor;
    circle: BooleanConstructor;
    processBeforeOpen: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    })[], unknown, unknown, () => true, boolean>;
    processBeforeClose: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    })[], unknown, unknown, () => true, boolean>;
    visible: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never, null, false>;
    "onUpdate:visible": {
        readonly type: import("vue").PropType<(val: boolean) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    disabled: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    trigger: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown, string, boolean>;
    virtualRef: {
        readonly type: import("vue").PropType<import("../..").Measurable>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    virtualTriggering: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onMouseenter: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onMouseleave: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onClick: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onKeydown: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onFocus: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onBlur: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onContextmenu: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    triggerClass: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    triggerStyle: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    strategy: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown, string, boolean>;
    fit: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    placement: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown, string, boolean>;
    zIndex: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    flip: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) & {}) | (() => boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) | ((new (...args: any[]) => (boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) & {}) | (() => boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }))[], unknown, unknown, () => {}, boolean>;
    windowResize: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    windowScroll: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    content: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    rawContent: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    popperClass: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown, string, boolean>;
    popperStyle: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, string, boolean>;
    persistent: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    showAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    hideAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
    autoClose: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
}, {
    ns: {
        namespace: import("vue").ComputedRef<string>;
        b: (blockSuffix?: string) => string;
        e: (element?: string | undefined) => string;
        m: (modifier?: string | undefined) => string;
        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
        em: (element?: string | undefined, modifier?: string | undefined) => string;
        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
        is: {
            (name: string, state: boolean | undefined): string;
            (name: string): string;
        };
        cssVar: (object: Record<string, string>) => Record<string, string>;
        cssVarName: (name: string) => string;
        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
        cssVarBlockName: (name: string) => string;
    };
    popperRef: import("vue").Ref<import("..").PopperExpose | undefined>;
    props: import("@vue/shared").LooseRequired<{
        readonly top: boolean;
        readonly bottom: boolean;
        readonly left: boolean;
        readonly right: boolean;
        readonly type: import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "border" | "shadow" | "border-thick", unknown>;
        readonly zIndex: number;
        readonly animation: string;
        readonly border: boolean;
        readonly shadow: boolean;
        readonly shift: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | Partial<Partial<{
            boundary: any;
            rootBoundary: import("../..").RootBoundary;
            elementContext: import("../../hooks/use-floating/core").ElementContext;
            altBoundary: boolean;
            padding: import("../..").Padding;
        }> & {
            mainAxis: boolean;
            crossAxis: boolean;
            limiter: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            };
        }>) & {}) | (() => boolean | Partial<Partial<{
            boundary: any;
            rootBoundary: import("../..").RootBoundary;
            elementContext: import("../../hooks/use-floating/core").ElementContext;
            altBoundary: boolean;
            padding: import("../..").Padding;
        }> & {
            mainAxis: boolean;
            crossAxis: boolean;
            limiter: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            };
        }>) | ((new (...args: any[]) => (boolean | Partial<Partial<{
            boundary: any;
            rootBoundary: import("../..").RootBoundary;
            elementContext: import("../../hooks/use-floating/core").ElementContext;
            altBoundary: boolean;
            padding: import("../..").Padding;
        }> & {
            mainAxis: boolean;
            crossAxis: boolean;
            limiter: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            };
        }>) & {}) | (() => boolean | Partial<Partial<{
            boundary: any;
            rootBoundary: import("../..").RootBoundary;
            elementContext: import("../../hooks/use-floating/core").ElementContext;
            altBoundary: boolean;
            padding: import("../..").Padding;
        }> & {
            mainAxis: boolean;
            crossAxis: boolean;
            limiter: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            };
        }>))[], unknown, unknown>;
        readonly shape: import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "default" | "circle" | "square", unknown>;
        readonly circle: boolean;
        readonly square: boolean;
        readonly offset: number;
        readonly visible: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never>;
        readonly flip: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown>;
        readonly showAfter: number;
        readonly hideAfter: number;
        readonly autoClose: number;
        readonly teleported: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly strategy: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>;
        readonly placement: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown>;
        readonly interactivity: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly windowResize: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly windowScroll: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly showArrow: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        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)[])[])[])[])[])[])[])[])[])[])[];
        readonly popperStyle: import("vue").StyleValue;
        readonly trigger: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>;
        readonly processBeforeOpen: () => boolean;
        readonly processBeforeClose: () => boolean;
        readonly effect: import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "dark" | "light", unknown>;
        readonly notHover: boolean;
        readonly borderThick: boolean;
        readonly disabled?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly color?: import("../..").Color | undefined;
        readonly loading?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly content?: string | undefined;
        readonly onFocus?: ((e: Event) => boolean | void) | undefined;
        readonly onMouseleave?: ((e: Event) => boolean | void) | undefined;
        readonly onBlur?: ((e: Event) => boolean | void) | undefined;
        readonly onKeydown?: ((e: Event) => boolean | void) | undefined;
        readonly onMouseenter?: ((e: Event) => boolean | void) | undefined;
        readonly onClick?: ((e: Event) => boolean | void) | undefined;
        readonly appendTo?: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown> | undefined;
        readonly fit?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly rawContent?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly persistent?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly virtualRef?: import("../..").Measurable | undefined;
        readonly virtualTriggering?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly onContextmenu?: ((e: Event) => boolean | void) | undefined;
        readonly triggerClass?: (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 triggerStyle?: import("vue").StyleValue | undefined;
        readonly "onUpdate:visible"?: ((val: boolean) => void) | undefined;
    } & {}>;
    tooltipStyle: import("vue").ComputedRef<Record<string, string>[]>;
    vsBaseClasses: string[];
    tooltipKls: import("vue").ComputedRef<(string | string[])[]>;
    readonly VsPopper: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
        processBeforeOpen: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        })[], unknown, unknown, () => true, boolean>;
        processBeforeClose: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        })[], unknown, unknown, () => true, boolean>;
        showArrow: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        loading: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        visible: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never, null, false>;
        "onUpdate:visible": {
            readonly type: import("vue").PropType<(val: boolean) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        disabled: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        trigger: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown, string, boolean>;
        virtualRef: {
            readonly type: import("vue").PropType<import("../..").Measurable>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        virtualTriggering: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onMouseenter: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onMouseleave: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onClick: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onKeydown: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onFocus: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onBlur: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onContextmenu: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        triggerClass: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        triggerStyle: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        animation: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        appendTo: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        strategy: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown, string, boolean>;
        fit: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        placement: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown, string, boolean>;
        zIndex: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        interactivity: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        flip: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown, () => {}, boolean>;
        shift: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown, () => {}, boolean>;
        windowResize: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        windowScroll: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        offset: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions) | ((new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions))[], unknown, unknown, number, boolean>;
        content: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        rawContent: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        popperClass: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown, string, boolean>;
        popperStyle: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, string, boolean>;
        persistent: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        showAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        hideAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
        autoClose: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    }, {
        selector: import("vue").ComputedRef<string>;
        id: import("vue").ComputedRef<string>;
        appendTo: import("vue").ComputedRef<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
        props: import("@vue/shared").LooseRequired<{
            [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
            readonly zIndex: number;
            readonly animation: string;
            readonly shift: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown>;
            readonly offset: import("../..").OffsetOptions;
            readonly visible: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never>;
            readonly flip: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown>;
            readonly showAfter: number;
            readonly hideAfter: number;
            readonly autoClose: number;
            readonly teleported: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly strategy: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>;
            readonly placement: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown>;
            readonly interactivity: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly windowResize: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly windowScroll: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly showArrow: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            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)[])[])[])[])[])[])[])[])[])[])[];
            readonly popperStyle: import("vue").StyleValue;
            readonly trigger: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>;
            readonly processBeforeOpen: () => boolean;
            readonly processBeforeClose: () => boolean;
            readonly disabled?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly loading?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly content?: string | undefined;
            readonly onFocus?: ((e: Event) => boolean | void) | undefined;
            readonly onMouseleave?: ((e: Event) => boolean | void) | undefined;
            readonly onBlur?: ((e: Event) => boolean | void) | undefined;
            readonly onKeydown?: ((e: Event) => boolean | void) | undefined;
            readonly onMouseenter?: ((e: Event) => boolean | void) | undefined;
            readonly onClick?: ((e: Event) => boolean | void) | undefined;
            readonly appendTo?: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown> | undefined;
            readonly fit?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly rawContent?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly persistent?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly virtualRef?: import("../..").Measurable | undefined;
            readonly virtualTriggering?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly onContextmenu?: ((e: Event) => boolean | void) | undefined;
            readonly triggerClass?: (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 triggerStyle?: import("vue").StyleValue | undefined;
            readonly "onUpdate:visible"?: ((val: boolean) => void) | undefined;
        } & {}>;
        emit: (event: string, ...args: any[]) => void;
        currentZIndex: import("vue").ComputedRef<number>;
        nextZIndex: () => number;
        zIndex: import("vue").ComputedRef<number>;
        triggerRef: import("vue").Ref<import("../..").ReferenceElement | undefined>;
        contentRef: import("vue").Ref<HTMLElement | undefined>;
        arrowRef: import("vue").Ref<HTMLElement | undefined>;
        open: import("vue").Ref<boolean>;
        toggleReason: import("vue").Ref<Event | undefined>;
        show: (event?: Event | undefined) => void;
        hide: (event?: Event | undefined) => void;
        hasUpdateHandler: import("vue").ComputedRef<boolean>;
        onOpen: (event?: Event | undefined) => void;
        onClose: (event?: Event | undefined) => void;
        update: () => void;
        popperPlacement: Readonly<import("vue").Ref<import("..").PopperPlacement>>;
        floatingStyles: Readonly<import("vue").Ref<{
            position: import("../..").Strategy;
            top: string;
            left: string;
            transform?: string | undefined;
            willChange?: string | undefined;
        }>>;
        controlled: import("vue").ComputedRef<boolean>;
        updatePopper: (shouldUpdateZIndex?: boolean) => void;
        onBlur: () => void;
        isFocusInsideContent: () => boolean;
        popperContent: import("vue").DefineComponent<{
            animation: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
            appendTo: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            visible: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
            teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            disabled: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            strategy: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown, string, boolean>;
            fit: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            placement: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown, string, boolean>;
            zIndex: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
            interactivity: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            flip: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown, () => {}, boolean>;
            shift: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown, () => {}, boolean>;
            windowResize: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            windowScroll: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            showArrow: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            offset: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions) | ((new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions))[], unknown, unknown, number, boolean>;
            content: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            rawContent: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            popperClass: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown, string, boolean>;
            popperStyle: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, string, boolean>;
            persistent: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
        }, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string | undefined) => string;
                m: (modifier?: string | undefined) => string;
                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
                em: (element?: string | undefined, modifier?: string | undefined) => string;
                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            contentRef: import("vue").Ref<HTMLElement | undefined>;
            controlled: import("vue").Ref<boolean>;
            open: import("vue").Ref<boolean>;
            trigger: import("vue").Ref<import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>>;
            updatePopper: (shouldUpdateZIndex?: boolean | undefined) => void;
            onOpen: (e?: Event | undefined) => void;
            onClose: (e?: Event | undefined) => void;
            onShow: () => void;
            onHide: () => void;
            onBeforeShow: () => void;
            onBeforeHide: () => void;
            props: import("@vue/shared").LooseRequired<{
                readonly zIndex: number;
                readonly animation: string;
                readonly shift: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    limiter?: {
                        fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                        options?: any;
                    } | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }) & {}) | (() => boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    limiter?: {
                        fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                        options?: any;
                    } | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }) | ((new (...args: any[]) => (boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    limiter?: {
                        fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                        options?: any;
                    } | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }) & {}) | (() => boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    limiter?: {
                        fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                        options?: any;
                    } | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }))[], unknown, unknown>;
                readonly offset: import("../..").OffsetOptions;
                readonly visible: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown>;
                readonly flip: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                    fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                    fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                    flipAlignment?: boolean | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }) & {}) | (() => boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                    fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                    fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                    flipAlignment?: boolean | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }) | ((new (...args: any[]) => (boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                    fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                    fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                    flipAlignment?: boolean | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }) & {}) | (() => boolean | {
                    padding?: import("../..").Padding | undefined;
                    rootBoundary?: import("../..").RootBoundary | undefined;
                    elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                    altBoundary?: boolean | undefined;
                    mainAxis?: boolean | undefined;
                    crossAxis?: boolean | undefined;
                    fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                    fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                    fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                    flipAlignment?: boolean | undefined;
                    boundary?: import("../..").Boundary | undefined;
                }))[], unknown, unknown>;
                readonly teleported: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly strategy: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>;
                readonly placement: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown>;
                readonly interactivity: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly windowResize: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly windowScroll: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly showArrow: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                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)[])[])[])[])[])[])[])[])[])[])[];
                readonly popperStyle: import("vue").StyleValue;
                readonly disabled?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly content?: string | undefined;
                readonly appendTo?: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown> | undefined;
                readonly fit?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly rawContent?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly persistent?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly onClose?: (() => any) | undefined;
                readonly onFocus?: (() => any) | undefined;
                readonly onMouseleave?: ((evt: MouseEvent) => any) | undefined;
                readonly onBlur?: (() => any) | undefined;
                readonly onMouseenter?: ((evt: MouseEvent) => any) | undefined;
            } & {}>;
            destroyed: import("vue").Ref<boolean>;
            persistentRef: import("vue").ComputedRef<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined>;
            shouldRender: import("vue").ComputedRef<boolean>;
            shouldShow: import("vue").ComputedRef<boolean>;
            popperKls: import("vue").ComputedRef<(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)[])[])[])[])[])[])[])[])[])[])[])[]>;
            togglePopperAlive: () => void;
            stopWhenControlled: () => true | undefined;
            onContentEnter: (event: unknown) => void;
            onContentLeave: (event: unknown) => void;
            onTransitionLeave: () => void;
            onBeforeEnter: () => void;
            onBeforeLeave: () => void;
            stopHandle: (() => void) | undefined;
            onAfterShow: () => void;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            mouseenter: (evt: MouseEvent) => boolean;
            mouseleave: (evt: MouseEvent) => boolean;
            focus: () => boolean;
            blur: () => boolean;
            close: () => boolean;
        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
            animation: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
            appendTo: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            visible: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown, null, boolean>;
            teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            disabled: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            strategy: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown, string, boolean>;
            fit: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            placement: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown, string, boolean>;
            zIndex: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
            interactivity: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            flip: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown, () => {}, boolean>;
            shift: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown, () => {}, boolean>;
            windowResize: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            windowScroll: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            showArrow: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
            offset: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions) | ((new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions))[], unknown, unknown, number, boolean>;
            content: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            rawContent: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            popperClass: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown, string, boolean>;
            popperStyle: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, string, boolean>;
            persistent: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
        }>> & {
            onClose?: (() => any) | undefined;
            onFocus?: (() => any) | undefined;
            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
            onBlur?: (() => any) | undefined;
            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
        }, {
            zIndex: number;
            animation: string;
            shift: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                limiter?: {
                    fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                    options?: any;
                } | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown>;
            offset: import("../..").OffsetOptions;
            visible: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], unknown, unknown>;
            flip: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) | ((new (...args: any[]) => (boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }) & {}) | (() => boolean | {
                padding?: import("../..").Padding | undefined;
                rootBoundary?: import("../..").RootBoundary | undefined;
                elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
                altBoundary?: boolean | undefined;
                mainAxis?: boolean | undefined;
                crossAxis?: boolean | undefined;
                fallbackPlacements?: import("..").PopperPlacement[] | undefined;
                fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
                fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
                flipAlignment?: boolean | undefined;
                boundary?: import("../..").Boundary | undefined;
            }))[], unknown, unknown>;
            teleported: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            strategy: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>;
            placement: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown>;
            interactivity: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            windowResize: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            windowScroll: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            showArrow: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            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)[])[])[])[])[])[])[])[])[])[])[];
            popperStyle: import("vue").StyleValue;
        }, {}>;
        popperTrigger: import("vue").DefineComponent<{
            disabled: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            trigger: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown, string, boolean>;
            virtualRef: {
                readonly type: import("vue").PropType<import("../..").Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            virtualTriggering: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onMouseenter: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onMouseleave: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onClick: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onKeydown: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onFocus: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onBlur: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onContextmenu: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            triggerClass: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            triggerStyle: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
        }, {
            ns: {
                namespace: import("vue").ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string | undefined) => string;
                m: (modifier?: string | undefined) => string;
                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
                em: (element?: string | undefined, modifier?: string | undefined) => string;
                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            triggerRef: import("vue").Ref<import("../..").ReferenceElement | undefined>;
            onOpen: (e?: Event | undefined) => void;
            onClose: (e?: Event | undefined) => void;
            onToggle: (e: Event) => void;
            props: import("@vue/shared").LooseRequired<{
                readonly trigger: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>;
                readonly disabled?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly onFocus?: ((e: Event) => boolean | void) | undefined;
                readonly onMouseleave?: ((e: Event) => boolean | void) | undefined;
                readonly onBlur?: ((e: Event) => boolean | void) | undefined;
                readonly onKeydown?: ((e: Event) => boolean | void) | undefined;
                readonly onMouseenter?: ((e: Event) => boolean | void) | undefined;
                readonly onClick?: ((e: Event) => boolean | void) | undefined;
                readonly virtualRef?: import("../..").Measurable | undefined;
                readonly virtualTriggering?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly onContextmenu?: ((e: Event) => boolean | void) | undefined;
                readonly triggerClass?: (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 triggerStyle?: import("vue").StyleValue | undefined;
            } & {}>;
            stopWhenControlledOrDisabled: () => true | undefined;
            trigger: import("vue").Ref<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>>;
            onMouseenter: (event: Event) => void;
            onMouseleave: (event: Event) => void;
            onClick: (event: Event) => void;
            onFocus: (event: Event) => void;
            onBlur: (event: Event) => void;
            onContextMenu: (event: Event) => void;
            readonly VsOnlyChild: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
            disabled: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            trigger: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown, string, boolean>;
            virtualRef: {
                readonly type: import("vue").PropType<import("../..").Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            virtualTriggering: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onMouseenter: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onMouseleave: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onClick: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onKeydown: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onFocus: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onBlur: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            onContextmenu: {
                readonly type: import("vue").PropType<(e: Event) => boolean | void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            triggerClass: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            triggerStyle: {
                readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
        }>>, {
            trigger: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>;
        }, {}>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        processBeforeOpen: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        })[], unknown, unknown, () => true, boolean>;
        processBeforeClose: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
            (): () => boolean;
            new (): any;
            readonly prototype: any;
        })[], unknown, unknown, () => true, boolean>;
        showArrow: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        loading: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        visible: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never, null, false>;
        "onUpdate:visible": {
            readonly type: import("vue").PropType<(val: boolean) => void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        disabled: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        trigger: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown, string, boolean>;
        virtualRef: {
            readonly type: import("vue").PropType<import("../..").Measurable>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        virtualTriggering: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onMouseenter: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onMouseleave: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onClick: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onKeydown: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onFocus: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onBlur: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        onContextmenu: {
            readonly type: import("vue").PropType<(e: Event) => boolean | void>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        triggerClass: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        triggerStyle: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        animation: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
        appendTo: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        strategy: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown, string, boolean>;
        fit: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        placement: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown, string, boolean>;
        zIndex: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
        interactivity: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        flip: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown, () => {}, boolean>;
        shift: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown, () => {}, boolean>;
        windowResize: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        windowScroll: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        offset: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions) | ((new (...args: any[]) => import("../..").OffsetOptions & {}) | (() => import("../..").OffsetOptions))[], unknown, unknown, number, boolean>;
        content: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        rawContent: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        popperClass: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown, string, boolean>;
        popperStyle: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, string, boolean>;
        persistent: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        showAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        hideAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
        autoClose: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    }>> & {
        [x: string & `on${string}`]: ((...args: any[]) => any) | undefined;
    }, {
        zIndex: number;
        animation: string;
        shift: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            limiter?: {
                fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
                options?: any;
            } | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown>;
        offset: import("../..").OffsetOptions;
        visible: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never>;
        flip: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) | ((new (...args: any[]) => (boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }) & {}) | (() => boolean | {
            padding?: import("../..").Padding | undefined;
            rootBoundary?: import("../..").RootBoundary | undefined;
            elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
            altBoundary?: boolean | undefined;
            mainAxis?: boolean | undefined;
            crossAxis?: boolean | undefined;
            fallbackPlacements?: import("..").PopperPlacement[] | undefined;
            fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
            fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
            flipAlignment?: boolean | undefined;
            boundary?: import("../..").Boundary | undefined;
        }))[], unknown, unknown>;
        showAfter: number;
        hideAfter: number;
        autoClose: number;
        teleported: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        strategy: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>;
        placement: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown>;
        interactivity: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        windowResize: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        windowScroll: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        showArrow: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        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)[])[])[])[])[])[])[])[])[])[])[];
        popperStyle: import("vue").StyleValue;
        trigger: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>;
        processBeforeOpen: () => boolean;
        processBeforeClose: () => boolean;
    }, {}>> & Record<string, any>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    shift: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) & {}) | (() => boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) | ((new (...args: any[]) => (boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) & {}) | (() => boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>))[], unknown, unknown, boolean, boolean>;
    color: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "primary" | "success" | "danger" | "warn" | "dark" | "text" | "light" | "secondary" | "facebook" | "twitter" | "youtube" | "pinterest" | "linkedin" | "snapchat" | "whatsapp" | "tumblr" | "reddit" | "spotify" | "amazon" | "medium" | "vimeo" | "skype" | "dribbble" | "slack" | "yahoo" | "twitch" | "discord" | "telegram" | "google-plus" | "messenger", import("../..").Color>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    animation: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
    interactivity: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    appendTo: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    type: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "border" | "shadow" | "border-thick", unknown, string, boolean>;
    shape: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "default" | "circle" | "square", unknown, string, boolean>;
    effect: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "dark" | "light", unknown, string, boolean>;
    showArrow: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    loading: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    offset: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bottom: BooleanConstructor;
    left: BooleanConstructor;
    right: BooleanConstructor;
    top: BooleanConstructor;
    notHover: BooleanConstructor;
    shadow: BooleanConstructor;
    border: BooleanConstructor;
    borderThick: BooleanConstructor;
    square: BooleanConstructor;
    circle: BooleanConstructor;
    processBeforeOpen: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    })[], unknown, unknown, () => true, boolean>;
    processBeforeClose: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    } | ((new (...args: any[]) => () => boolean) | (() => () => boolean) | {
        (): () => boolean;
        new (): any;
        readonly prototype: any;
    })[], unknown, unknown, () => true, boolean>;
    visible: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never, null, false>;
    "onUpdate:visible": {
        readonly type: import("vue").PropType<(val: boolean) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    disabled: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    trigger: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown, string, boolean>;
    virtualRef: {
        readonly type: import("vue").PropType<import("../..").Measurable>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    virtualTriggering: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onMouseenter: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onMouseleave: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onClick: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onKeydown: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onFocus: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onBlur: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    onContextmenu: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    triggerClass: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    triggerStyle: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    strategy: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown, string, boolean>;
    fit: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    placement: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown, string, boolean>;
    zIndex: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    flip: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) & {}) | (() => boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) | ((new (...args: any[]) => (boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) & {}) | (() => boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }))[], unknown, unknown, () => {}, boolean>;
    windowResize: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    windowScroll: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    content: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    rawContent: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    popperClass: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (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)[])[])[])[])[])[])[])[])[])[])[]) & {}) | (() => 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)[])[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown, string, boolean>;
    popperStyle: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, string, boolean>;
    persistent: {
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    showAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    hideAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
    autoClose: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
}>>, {
    top: boolean;
    bottom: boolean;
    left: boolean;
    right: boolean;
    type: import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "border" | "shadow" | "border-thick", unknown>;
    zIndex: number;
    animation: string;
    border: boolean;
    shadow: boolean;
    shift: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) & {}) | (() => boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) | ((new (...args: any[]) => (boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>) & {}) | (() => boolean | Partial<Partial<{
        boundary: any;
        rootBoundary: import("../..").RootBoundary;
        elementContext: import("../../hooks/use-floating/core").ElementContext;
        altBoundary: boolean;
        padding: import("../..").Padding;
    }> & {
        mainAxis: boolean;
        crossAxis: boolean;
        limiter: {
            fn: (state: import("../../hooks/use-floating/core").MiddlewareState) => import("../..").Coords;
            options?: any;
        };
    }>))[], unknown, unknown>;
    shape: import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "default" | "circle" | "square", unknown>;
    circle: boolean;
    square: boolean;
    offset: number;
    visible: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never>;
    flip: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) & {}) | (() => boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) | ((new (...args: any[]) => (boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }) & {}) | (() => boolean | {
        padding?: import("../..").Padding | undefined;
        rootBoundary?: import("../..").RootBoundary | undefined;
        elementContext?: import("../../hooks/use-floating/core").ElementContext | undefined;
        altBoundary?: boolean | undefined;
        mainAxis?: boolean | undefined;
        crossAxis?: boolean | undefined;
        fallbackPlacements?: import("..").PopperPlacement[] | undefined;
        fallbackStrategy?: "bestFit" | "initialPlacement" | undefined;
        fallbackAxisSideDirection?: "none" | "end" | "start" | undefined;
        flipAlignment?: boolean | undefined;
        boundary?: import("../..").Boundary | undefined;
    }))[], unknown, unknown>;
    showAfter: number;
    hideAfter: number;
    autoClose: number;
    teleported: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    strategy: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>;
    placement: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement) | ((new (...args: any[]) => import("..").PopperPlacement & {}) | (() => import("..").PopperPlacement))[], "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end", unknown>;
    interactivity: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    windowResize: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    windowScroll: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    showArrow: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    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)[])[])[])[])[])[])[])[])[])[])[];
    popperStyle: import("vue").StyleValue;
    trigger: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>) | ((new (...args: any[]) => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType> & {}) | (() => import("vuesax-alpha/es/utils").Arrayable<import("..").PopperTriggerType>))[], unknown, unknown>;
    processBeforeOpen: () => boolean;
    processBeforeClose: () => boolean;
    effect: import("vuesax-alpha/es/utils").VsPropMergeType<StringConstructor, "dark" | "light", unknown>;
    notHover: boolean;
    borderThick: boolean;
}, {}>> & Record<string, any>;
export default VsTooltip;
export * from './src/tooltip';