export declare const VsSelect: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
    readonly showAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly hideAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly flip: {
        readonly default: true;
        readonly type: import("vue").PropType<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 required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        readonly __vsPropKey: true;
    };
    readonly fit: {
        readonly default: true;
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        readonly __vsPropKey: true;
    };
    readonly 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;
    };
    readonly onClick: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onBlur: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onFocus: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onMouseenter: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onMouseleave: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onContextmenu: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onKeydown: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly strategy: {
        readonly default: "absolute";
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        readonly __vsPropKey: true;
    };
    readonly teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    readonly modelValue: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectValue & {}) | (() => import("./src/tokens").SelectValue) | ((new (...args: any[]) => import("./src/tokens").SelectValue & {}) | (() => import("./src/tokens").SelectValue))[], unknown, unknown, "", boolean>;
    readonly notValue: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, "", boolean>;
    readonly loadingText: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly noMatchText: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly noDataText: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly allowCreate: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly multiple: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly multipleLimit: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly filter: {
        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;
    };
    readonly filterMethod: {
        readonly type: import("vue").PropType<(val: string) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly collapseChips: {
        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;
    };
    readonly maxCollapseChips: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
    readonly defaultFirstOption: {
        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;
    };
    readonly 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;
    };
    readonly color: {
        readonly default: "primary";
        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;
        readonly __vsPropKey: true;
    };
    readonly state: {
        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;
    };
    readonly block: {
        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;
    };
    readonly hideScrollbar: {
        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;
    };
    readonly labelFloat: {
        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;
    };
    readonly label: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, null, boolean>;
    readonly placeholder: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, null, boolean>;
    readonly shape: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "square", unknown, "", boolean>;
    readonly id: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly nativeScrollbar: {
        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;
    };
    readonly clearable: {
        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;
    };
}, {
    messageTypes: string[];
    props: import("@vue/shared").LooseRequired<{
        readonly modelValue: import("./src/tokens").SelectValue;
        readonly color: import("../..").Color;
        readonly label: string;
        readonly shape: "square";
        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 multiple: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly notValue: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
        readonly placeholder: string;
        readonly showAfter: number;
        readonly hideAfter: 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 fit: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly allowCreate: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly multipleLimit: number;
        readonly maxCollapseChips: number;
        readonly filter?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        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 block?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly id?: string | undefined;
        readonly clearable?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly labelFloat?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly state?: import("../..").Color | undefined;
        readonly onFocus?: (((e: Event) => boolean | void) & ((event: Event | FocusEvent) => any)) | undefined;
        readonly onMouseleave?: ((e: Event) => boolean | void) | undefined;
        readonly onBlur?: (((e: Event) => boolean | void) & ((event: Event | FocusEvent) => any)) | undefined;
        readonly onKeydown?: ((e: Event) => boolean | void) | undefined;
        readonly onMouseenter?: ((e: Event) => boolean | void) | undefined;
        readonly onClick?: ((e: Event) => boolean | void) | undefined;
        readonly onContextmenu?: ((e: Event) => boolean | void) | undefined;
        readonly loadingText?: string | undefined;
        readonly noMatchText?: string | undefined;
        readonly noDataText?: string | undefined;
        readonly filterMethod?: ((val: string) => void) | undefined;
        readonly collapseChips?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly defaultFirstOption?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly hideScrollbar?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly nativeScrollbar?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
        readonly "onUpdate:modelValue"?: ((val: import("./src/tokens").SelectValue) => any) | undefined;
        readonly onChange?: ((val: import("./src/tokens").SelectValue) => any) | undefined;
        readonly onClear?: (() => any) | undefined;
        readonly "onVisible-change"?: ((val: boolean) => any) | undefined;
        readonly "onRemove-tag"?: ((val: import("./src/tokens").SelectOptionValue) => any) | undefined;
    } & {}>;
    emit: ((event: "update:modelValue", val: import("./src/tokens").SelectValue) => void) & ((event: "change", val: import("./src/tokens").SelectValue) => void) & ((event: "focus", event: Event | FocusEvent) => void) & ((event: "blur", event: Event | FocusEvent) => void) & ((event: "clear") => void) & ((event: "visible-change", val: boolean) => void) & ((event: "remove-tag", val: import("./src/tokens").SelectOptionValue) => void);
    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;
    };
    states: import("./src/tokens").SelectStates;
    color: import("vue").ComputedRef<import("../..").Color | undefined>;
    colorCssVar: import("vue").ComputedRef<Record<string, string>>;
    optionsAnimation: import("vue").ComputedRef<string>;
    showNewOption: import("vue").ComputedRef<boolean | undefined>;
    debouncedQueryChange: import("lodash").DebouncedFunc<(e: any) => void>;
    managePlaceholder: () => void;
    deletePrevTag: (e: KeyboardEvent) => void;
    deleteTag: (tag: import("./src/tokens").SelectOptionValue) => void;
    handleClearClick: () => void;
    showClose: import("vue").ComputedRef<boolean | undefined>;
    inputId: import("vue").Ref<string>;
    emptyText: import("vue").ComputedRef<string | null>;
    readonly: import("vue").ComputedRef<boolean>;
    input: import("vue").Ref<HTMLInputElement | undefined>;
    reference: import("vue").Ref<HTMLInputElement | undefined>;
    showTagList: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
    collapseTagList: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
    chips: import("vue").Ref<HTMLElement | undefined>;
    popperRef: import("vue").Ref<import("..").PopperExpose | undefined>;
    selectDisabled: import("vue").ComputedRef<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined>;
    selectWrapper: import("vue").Ref<HTMLElement | undefined>;
    handleMouseEnter: () => void;
    handleMouseLeave: () => void;
    handleTarget: (target: import("./src/tokens").SelectTargetElement | null, condition?: boolean) => void;
    selectOption: () => void;
    handleComposition: (event: Event) => void;
    navigateOptions: (direction?: string) => void;
    handleKeydownEscape: (event: KeyboardEvent | Event) => void;
    dropMenuVisible: import("vue").WritableComputedRef<boolean>;
    debouncedOnInputChange: import("lodash").DebouncedFunc<() => void>;
    handleFocus: (event: FocusEvent) => void;
    handleBlur: (event: FocusEvent) => void;
    toggleMenu: (e?: MouseEvent | undefined) => void;
    handleMenuEnter: () => void;
    handleResize: () => void;
    setSelected: () => void;
    handleClose: () => void;
    onOptionCreate: (value: import("./src/tokens").SelectOptionValue, option: import("./src/tokens").SelectOptionContext) => void;
    onOptionDestroy: (value: import("./src/tokens").SelectOptionValue, option: import("./src/tokens").SelectOptionContext) => void;
    handleOptionSelect: (option: import("./src/tokens").SelectOptionContext, byClick: boolean) => void;
    focus: () => void;
    blur: () => void;
    processBeforeOpen: () => boolean;
    processBeforeClose: () => boolean;
    queryChange: import("vue").ShallowRef<string>;
    optionsArray: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
    cachedOptionsArray: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
    selectedArray: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
    visible: import("vue").Ref<boolean>;
    hoverIndex: import("vue").Ref<number>;
    query: import("vue").Ref<string>;
    popperPaneRef: import("vue").ComputedRef<HTMLElement | undefined>;
    selectKls: import("vue").ComputedRef<(string | {
        [x: string]: string | import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
    })[]>;
    selectStyle: import("vue").ComputedRef<Record<string, string>[]>;
    readonly isEqual: (value: any, other: any) => boolean;
    readonly vClickOutside: import("vue").ObjectDirective<any, any>;
    readonly VsIcon: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
        readonly size: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly color: import("vuesax-alpha/es/utils").VsPropFinalized<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, "", boolean>;
    }, {
        props: import("@vue/shared").LooseRequired<{
            readonly color: import("../..").Color;
            readonly size?: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown> | undefined;
        } & {}>;
        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;
        };
        style: import("vue").ComputedRef<import("vue").CSSProperties>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly size: {
            readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly color: import("vuesax-alpha/es/utils").VsPropFinalized<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, "", boolean>;
    }>>, {
        readonly color: import("../..").Color;
    }, {}>> & Record<string, any>;
    readonly IconClose: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
        readonly hover: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly scale: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown, 1, 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;
        };
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly hover: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly scale: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown, 1, boolean>;
    }>>, {
        readonly scale: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>;
    }, {}>> & Record<string, any>;
    readonly IconLoading: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{}, {
        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;
        };
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>> & Record<string, any>;
    readonly VsCollapseTransition: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{}, {
        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;
        };
        on: {
            beforeEnter(el: import("vue").RendererElement): void;
            enter(el: import("vue").RendererElement): void;
            afterEnter(el: import("vue").RendererElement): void;
            beforeLeave(el: import("vue").RendererElement): void;
            leave(el: import("vue").RendererElement): void;
            afterLeave(el: import("vue").RendererElement): void;
        };
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>>;
    readonly VsScrollbar: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
        readonly height: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
        readonly maxHeight: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
        readonly native: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly wrapStyle: 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, "", boolean>;
        readonly wrapClass: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
        readonly viewClass: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
        readonly viewStyle: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
        readonly noresize: {
            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;
        };
        readonly tag: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
        readonly always: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly minSize: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
        readonly thickness: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 6, boolean>;
    }, {
        COMPONENT_NAME: string;
        props: import("@vue/shared").LooseRequired<{
            readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly height: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
            readonly maxHeight: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
            readonly native: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly wrapStyle: import("vue").StyleValue;
            readonly wrapClass: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
            readonly viewClass: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
            readonly viewStyle: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown>;
            readonly tag: string;
            readonly minSize: number;
            readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
            readonly noresize?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly onScroll?: ((args_0: import("..").ScrollEmitParams) => any) | undefined;
        } & {}>;
        emit: (event: "scroll", args_0: import("..").ScrollEmitParams) => void;
        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;
        };
        stopResizeObserver: (() => void) | undefined;
        stopResizeListener: (() => void) | undefined;
        scrollbarRef: import("vue").Ref<HTMLDivElement | undefined>;
        wrapRef: import("vue").Ref<HTMLDivElement | undefined>;
        resizeRef: import("vue").Ref<HTMLElement | undefined>;
        sizeWidth: import("vue").Ref<string>;
        sizeHeight: import("vue").Ref<string>;
        barRef: import("vue").Ref<({
            $: import("vue").ComponentInternalInstance;
            $data: {};
            $props: {
                readonly always?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                readonly thickness?: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown> | undefined;
                readonly ratioX?: number | undefined;
                readonly ratioY?: number | undefined;
                key?: string | number | symbol | undefined;
                style?: unknown;
                readonly height?: string | undefined;
                readonly width?: string | undefined;
                ref?: import("vue").VNodeRef | undefined;
                ref_for?: boolean | undefined;
                ref_key?: string | undefined;
                onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[] | undefined;
                onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[] | undefined;
                onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[] | undefined;
                onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[] | undefined;
                onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[] | undefined;
                onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                    [key: string]: any;
                }>) => void)[] | undefined;
                class?: unknown;
            };
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: import("vue").Slot<any> | undefined;
            }>;
            $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
            $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                readonly always: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly width: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly height: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly ratioX: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
                readonly ratioY: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
                readonly thickness: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 6, boolean>;
            }>>, {
                props: import("@vue/shared").LooseRequired<{
                    readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                    readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
                    readonly ratioX: number;
                    readonly ratioY: number;
                    readonly height?: string | undefined;
                    readonly width?: string | undefined;
                } & {}>;
                moveX: import("vue").Ref<number>;
                moveY: import("vue").Ref<number>;
                handleScroll: (wrap: HTMLDivElement) => void;
                Thumb: import("vue").DefineComponent<{
                    readonly vertical: {
                        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;
                    };
                    readonly size: {
                        readonly type: import("vue").PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __vsPropKey: true;
                    };
                    readonly move: {
                        readonly type: import("vue").PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __vsPropKey: true;
                    };
                    readonly ratio: {
                        readonly type: import("vue").PropType<number>;
                        readonly required: true;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __vsPropKey: true;
                    };
                    readonly always: {
                        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;
                    };
                }, {
                    COMPONENT_NAME: string;
                    props: import("@vue/shared").LooseRequired<{
                        readonly ratio: number;
                        readonly size?: string | undefined;
                        readonly move?: number | undefined;
                        readonly always?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                        readonly vertical?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                    } & {}>;
                    scrollbar: import("../..").ScrollbarContext;
                    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;
                    };
                    instance: import("vue").Ref<HTMLDivElement | undefined>;
                    thumb: import("vue").Ref<HTMLDivElement | undefined>;
                    thumbState: import("vue").Ref<{
                        X?: number | undefined;
                        Y?: number | undefined;
                    }>;
                    visible: import("vue").Ref<boolean>;
                    cursorDown: boolean;
                    cursorLeave: boolean;
                    originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
                    bar: import("vue").ComputedRef<{
                        readonly offset: "offsetHeight";
                        readonly scroll: "scrollTop";
                        readonly scrollSize: "scrollHeight";
                        readonly size: "height";
                        readonly key: "vertical";
                        readonly axis: "Y";
                        readonly client: "clientY";
                        readonly direction: "top";
                    } | {
                        readonly offset: "offsetWidth";
                        readonly scroll: "scrollLeft";
                        readonly scrollSize: "scrollWidth";
                        readonly size: "width";
                        readonly key: "horizontal";
                        readonly axis: "X";
                        readonly client: "clientX";
                        readonly direction: "left";
                    }>;
                    thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                    offsetRatio: import("vue").ComputedRef<number>;
                    clickThumbHandler: (e: MouseEvent) => void;
                    clickTrackHandler: (e: MouseEvent) => void;
                    startDrag: (e: MouseEvent) => void;
                    mouseMoveDocumentHandler: (e: MouseEvent) => void;
                    mouseUpDocumentHandler: () => void;
                    mouseMoveScrollbarHandler: () => void;
                    mouseLeaveScrollbarHandler: () => void;
                    restoreOnselectstart: () => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                    readonly vertical: {
                        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;
                    };
                    readonly size: {
                        readonly type: import("vue").PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __vsPropKey: true;
                    };
                    readonly move: {
                        readonly type: import("vue").PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __vsPropKey: true;
                    };
                    readonly ratio: {
                        readonly type: import("vue").PropType<number>;
                        readonly required: true;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __vsPropKey: true;
                    };
                    readonly always: {
                        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;
                    };
                }>>, {}, {}>;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
                readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
                readonly ratioX: number;
                readonly ratioY: number;
            }, {}, string, {}> & {
                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
                created?: ((() => void) | (() => void)[]) | undefined;
                beforeMount?: ((() => void) | (() => void)[]) | undefined;
                mounted?: ((() => void) | (() => void)[]) | undefined;
                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
                updated?: ((() => void) | (() => void)[]) | undefined;
                activated?: ((() => void) | (() => void)[]) | undefined;
                deactivated?: ((() => void) | (() => void)[]) | undefined;
                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
                destroyed?: ((() => void) | (() => void)[]) | undefined;
                unmounted?: ((() => void) | (() => void)[]) | undefined;
                renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
                renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
                errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
            };
            $forceUpdate: () => void;
            $nextTick: typeof import("vue").nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
        } & Readonly<import("vue").ExtractPropTypes<{
            readonly always: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly width: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly height: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly ratioX: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
            readonly ratioY: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
            readonly thickness: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 6, boolean>;
        }>> & import("vue").ShallowUnwrapRef<{
            props: import("@vue/shared").LooseRequired<{
                readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
                readonly ratioX: number;
                readonly ratioY: number;
                readonly height?: string | undefined;
                readonly width?: string | undefined;
            } & {}>;
            moveX: import("vue").Ref<number>;
            moveY: import("vue").Ref<number>;
            handleScroll: (wrap: HTMLDivElement) => void;
            Thumb: import("vue").DefineComponent<{
                readonly vertical: {
                    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;
                };
                readonly size: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly move: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly ratio: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly always: {
                    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;
                };
            }, {
                COMPONENT_NAME: string;
                props: import("@vue/shared").LooseRequired<{
                    readonly ratio: number;
                    readonly size?: string | undefined;
                    readonly move?: number | undefined;
                    readonly always?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                    readonly vertical?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                } & {}>;
                scrollbar: import("../..").ScrollbarContext;
                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;
                };
                instance: import("vue").Ref<HTMLDivElement | undefined>;
                thumb: import("vue").Ref<HTMLDivElement | undefined>;
                thumbState: import("vue").Ref<{
                    X?: number | undefined;
                    Y?: number | undefined;
                }>;
                visible: import("vue").Ref<boolean>;
                cursorDown: boolean;
                cursorLeave: boolean;
                originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
                bar: import("vue").ComputedRef<{
                    readonly offset: "offsetHeight";
                    readonly scroll: "scrollTop";
                    readonly scrollSize: "scrollHeight";
                    readonly size: "height";
                    readonly key: "vertical";
                    readonly axis: "Y";
                    readonly client: "clientY";
                    readonly direction: "top";
                } | {
                    readonly offset: "offsetWidth";
                    readonly scroll: "scrollLeft";
                    readonly scrollSize: "scrollWidth";
                    readonly size: "width";
                    readonly key: "horizontal";
                    readonly axis: "X";
                    readonly client: "clientX";
                    readonly direction: "left";
                }>;
                thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                offsetRatio: import("vue").ComputedRef<number>;
                clickThumbHandler: (e: MouseEvent) => void;
                clickTrackHandler: (e: MouseEvent) => void;
                startDrag: (e: MouseEvent) => void;
                mouseMoveDocumentHandler: (e: MouseEvent) => void;
                mouseUpDocumentHandler: () => void;
                mouseMoveScrollbarHandler: () => void;
                mouseLeaveScrollbarHandler: () => void;
                restoreOnselectstart: () => void;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                readonly vertical: {
                    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;
                };
                readonly size: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly move: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly ratio: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly always: {
                    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;
                };
            }>>, {}, {}>;
        }> & {} & import("vue").ComponentCustomProperties & {}) | undefined>;
        ratioY: import("vue").Ref<number>;
        ratioX: import("vue").Ref<number>;
        style: import("vue").ComputedRef<import("vue").StyleValue>;
        wrapKls: import("vue").ComputedRef<(string | unknown[] | {
            [x: string]: boolean;
        })[]>;
        resizeKls: import("vue").ComputedRef<import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>[]>;
        handleScroll: () => void;
        scrollTo: (arg1: unknown, arg2?: number | undefined) => void;
        setScrollTop: (value: number) => void;
        setScrollLeft: (value: number) => void;
        update: () => void;
        Bar: import("vue").DefineComponent<{
            readonly always: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly width: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly height: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly ratioX: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
            readonly ratioY: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
            readonly thickness: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 6, boolean>;
        }, {
            props: import("@vue/shared").LooseRequired<{
                readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
                readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
                readonly ratioX: number;
                readonly ratioY: number;
                readonly height?: string | undefined;
                readonly width?: string | undefined;
            } & {}>;
            moveX: import("vue").Ref<number>;
            moveY: import("vue").Ref<number>;
            handleScroll: (wrap: HTMLDivElement) => void;
            Thumb: import("vue").DefineComponent<{
                readonly vertical: {
                    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;
                };
                readonly size: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly move: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly ratio: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly always: {
                    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;
                };
            }, {
                COMPONENT_NAME: string;
                props: import("@vue/shared").LooseRequired<{
                    readonly ratio: number;
                    readonly size?: string | undefined;
                    readonly move?: number | undefined;
                    readonly always?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                    readonly vertical?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
                } & {}>;
                scrollbar: import("../..").ScrollbarContext;
                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;
                };
                instance: import("vue").Ref<HTMLDivElement | undefined>;
                thumb: import("vue").Ref<HTMLDivElement | undefined>;
                thumbState: import("vue").Ref<{
                    X?: number | undefined;
                    Y?: number | undefined;
                }>;
                visible: import("vue").Ref<boolean>;
                cursorDown: boolean;
                cursorLeave: boolean;
                originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
                bar: import("vue").ComputedRef<{
                    readonly offset: "offsetHeight";
                    readonly scroll: "scrollTop";
                    readonly scrollSize: "scrollHeight";
                    readonly size: "height";
                    readonly key: "vertical";
                    readonly axis: "Y";
                    readonly client: "clientY";
                    readonly direction: "top";
                } | {
                    readonly offset: "offsetWidth";
                    readonly scroll: "scrollLeft";
                    readonly scrollSize: "scrollWidth";
                    readonly size: "width";
                    readonly key: "horizontal";
                    readonly axis: "X";
                    readonly client: "clientX";
                    readonly direction: "left";
                }>;
                thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                offsetRatio: import("vue").ComputedRef<number>;
                clickThumbHandler: (e: MouseEvent) => void;
                clickTrackHandler: (e: MouseEvent) => void;
                startDrag: (e: MouseEvent) => void;
                mouseMoveDocumentHandler: (e: MouseEvent) => void;
                mouseUpDocumentHandler: () => void;
                mouseMoveScrollbarHandler: () => void;
                mouseLeaveScrollbarHandler: () => void;
                restoreOnselectstart: () => void;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                readonly vertical: {
                    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;
                };
                readonly size: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly move: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly ratio: {
                    readonly type: import("vue").PropType<number>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __vsPropKey: true;
                };
                readonly always: {
                    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;
                };
            }>>, {}, {}>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
            readonly always: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly width: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly height: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly ratioX: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
            readonly ratioY: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
            readonly thickness: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 6, boolean>;
        }>>, {
            readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
            readonly ratioX: number;
            readonly ratioY: number;
        }, {}>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        scroll: ({ scrollTop, scrollLeft }: import("..").ScrollEmitParams) => boolean;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly height: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
        readonly maxHeight: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
        readonly native: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly wrapStyle: 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, "", boolean>;
        readonly wrapClass: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
        readonly viewClass: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
        readonly viewStyle: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
        readonly noresize: {
            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;
        };
        readonly tag: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
        readonly always: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly minSize: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
        readonly thickness: import("vuesax-alpha/es/utils").VsPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, 6, boolean>;
    }>> & {
        onScroll?: ((args_0: import("..").ScrollEmitParams) => any) | undefined;
    }, {
        readonly always: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly height: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
        readonly maxHeight: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
        readonly native: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly wrapStyle: import("vue").StyleValue;
        readonly wrapClass: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
        readonly viewClass: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
        readonly viewStyle: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown>;
        readonly tag: string;
        readonly minSize: number;
        readonly thickness: import("vuesax-alpha/es/utils").VsPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
    }, {}>> & Record<string, any>;
    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>;
    readonly ChevronDown: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
    readonly useVuesaxBaseComponent: (color?: import("vuesax-alpha/es/utils").MaybeRef<string | undefined>) => string[];
    VsOption: import("vue").DefineComponent<{
        readonly value: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, null, boolean>;
        readonly disabled: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly label: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly created: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, 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;
        };
        props: import("@vue/shared").LooseRequired<{
            readonly disabled: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly value: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
            readonly created: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly label?: string | undefined;
        } & {}>;
        value: import("vue").Ref<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>>;
        select: import("./src/tokens").SelectContext;
        selectRegister: (option: import("./src/tokens").SelectOptionContext) => {
            unregister: () => void;
            updateOption: (option: import("./src/tokens").SelectOptionContext) => void;
        };
        optionGroupRegister: ((option: import("./src/tokens").SelectOptionContext) => {
            unregister: () => void;
        }) | undefined;
        selectGroup: {
            disabled: boolean;
        };
        el: import("vue").Ref<HTMLElement | undefined>;
        isObject: import("vue").ComputedRef<boolean>;
        limitReached: import("vue").ComputedRef<boolean>;
        currentLabel: import("vue").ComputedRef<string>;
        isDisabled: import("vue").ComputedRef<boolean>;
        isSelected: import("vue").ComputedRef<boolean>;
        states: import("./src/tokens").SelectOptionContext;
        unregister: () => void;
        updateOption: (option: import("./src/tokens").SelectOptionContext) => void;
        optionGroupUnregister: (() => void) | undefined;
        hoverItem: () => void;
        optionKls: import("vue").ComputedRef<string[]>;
        selectOptionClick: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly value: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, null, boolean>;
        readonly disabled: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly label: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly created: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    }>>, {
        readonly disabled: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly value: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
        readonly created: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    }, {}>;
    VsChip: 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;
        };
        hit: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        shape: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "square", unknown, string, boolean>;
        showClose: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, 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;
        };
        select: import("./src/tokens").SelectContext;
        props: import("@vue/shared").LooseRequired<{
            readonly shape: "square";
            readonly showClose: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly hit: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly disabled?: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
            readonly onClose?: ((e: Event | MouseEvent) => any) | undefined;
            readonly onClick?: ((e: Event | MouseEvent) => any) | undefined;
        } & {}>;
        emit: ((event: "click", e: Event | MouseEvent) => void) & ((event: "close", e: Event | MouseEvent) => void);
        chipKls: import("vue").ComputedRef<string[]>;
        onClick: (e: Event) => void;
        onClose: (e: Event) => void;
        onMouseEnterClose: () => void;
        onMouseLeaveClose: () => void;
        readonly IconClose: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
            readonly hover: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly scale: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown, 1, 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;
            };
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
            readonly hover: {
                readonly type: import("vue").PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __vsPropKey: true;
            };
            readonly scale: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown, 1, boolean>;
        }>>, {
            readonly scale: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>;
        }, {}>> & Record<string, any>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        click: (e: Event | MouseEvent) => boolean;
        close: (e: Event | MouseEvent) => boolean;
    }, 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;
        };
        hit: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        shape: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "square", unknown, string, boolean>;
        showClose: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    }>> & {
        onClose?: ((e: Event | MouseEvent) => any) | undefined;
        onClick?: ((e: Event | MouseEvent) => any) | undefined;
    }, {
        shape: "square";
        showClose: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        hit: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    }, {}>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    'update:modelValue': (val: import("./src/tokens").SelectValue) => boolean;
    'visible-change': (val: boolean) => boolean;
    'remove-tag': (val: import("./src/tokens").SelectOptionValue) => import("./src/tokens").SelectOptionValue;
    focus: (event: Event | FocusEvent) => boolean;
    blur: (event: Event | FocusEvent) => boolean;
    change: (val: import("./src/tokens").SelectValue) => boolean;
    clear: () => boolean;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly showAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly hideAfter: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly flip: {
        readonly default: true;
        readonly type: import("vue").PropType<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 required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        readonly __vsPropKey: true;
    };
    readonly fit: {
        readonly default: true;
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        readonly __vsPropKey: true;
    };
    readonly 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;
    };
    readonly onClick: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onBlur: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onFocus: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onMouseenter: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onMouseleave: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onContextmenu: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly onKeydown: {
        readonly type: import("vue").PropType<(e: Event) => boolean | void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly strategy: {
        readonly default: "absolute";
        readonly type: import("vue").PropType<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy) | ((new (...args: any[]) => import("../..").Strategy & {}) | (() => import("../..").Strategy))[], "fixed" | "absolute", unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        readonly __vsPropKey: true;
    };
    readonly teleported: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    readonly modelValue: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectValue & {}) | (() => import("./src/tokens").SelectValue) | ((new (...args: any[]) => import("./src/tokens").SelectValue & {}) | (() => import("./src/tokens").SelectValue))[], unknown, unknown, "", boolean>;
    readonly notValue: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, "", boolean>;
    readonly loadingText: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly noMatchText: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly noDataText: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly allowCreate: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly multiple: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly multipleLimit: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly filter: {
        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;
    };
    readonly filterMethod: {
        readonly type: import("vue").PropType<(val: string) => void>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly collapseChips: {
        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;
    };
    readonly maxCollapseChips: import("vuesax-alpha/es/utils").VsPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
    readonly defaultFirstOption: {
        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;
    };
    readonly 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;
    };
    readonly color: {
        readonly default: "primary";
        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;
        readonly __vsPropKey: true;
    };
    readonly state: {
        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;
    };
    readonly block: {
        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;
    };
    readonly hideScrollbar: {
        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;
    };
    readonly labelFloat: {
        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;
    };
    readonly label: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, null, boolean>;
    readonly placeholder: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, unknown, unknown, null, boolean>;
    readonly shape: import("vuesax-alpha/es/utils").VsPropFinalized<StringConstructor, "square", unknown, "", boolean>;
    readonly id: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly nativeScrollbar: {
        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;
    };
    readonly clearable: {
        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;
    };
}>> & {
    "onUpdate:modelValue"?: ((val: import("./src/tokens").SelectValue) => any) | undefined;
    onChange?: ((val: import("./src/tokens").SelectValue) => any) | undefined;
    onFocus?: ((event: Event | FocusEvent) => any) | undefined;
    onBlur?: ((event: Event | FocusEvent) => any) | undefined;
    onClear?: (() => any) | undefined;
    "onVisible-change"?: ((val: boolean) => any) | undefined;
    "onRemove-tag"?: ((val: import("./src/tokens").SelectOptionValue) => any) | undefined;
}, {
    readonly modelValue: import("./src/tokens").SelectValue;
    readonly color: import("../..").Color;
    readonly label: string;
    readonly shape: "square";
    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 multiple: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly notValue: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
    readonly placeholder: string;
    readonly showAfter: number;
    readonly hideAfter: 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 fit: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly allowCreate: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly multipleLimit: number;
    readonly maxCollapseChips: number;
}, {}>> & {
    Option: import("vue").DefineComponent<{
        readonly value: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, null, boolean>;
        readonly disabled: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly label: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly created: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, 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;
        };
        props: import("@vue/shared").LooseRequired<{
            readonly disabled: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly value: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
            readonly created: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
            readonly label?: string | undefined;
        } & {}>;
        value: import("vue").Ref<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>>;
        select: import("./src/tokens").SelectContext;
        selectRegister: (option: import("./src/tokens").SelectOptionContext) => {
            unregister: () => void;
            updateOption: (option: import("./src/tokens").SelectOptionContext) => void;
        };
        optionGroupRegister: ((option: import("./src/tokens").SelectOptionContext) => {
            unregister: () => void;
        }) | undefined;
        selectGroup: {
            disabled: boolean;
        };
        el: import("vue").Ref<HTMLElement | undefined>;
        isObject: import("vue").ComputedRef<boolean>;
        limitReached: import("vue").ComputedRef<boolean>;
        currentLabel: import("vue").ComputedRef<string>;
        isDisabled: import("vue").ComputedRef<boolean>;
        isSelected: import("vue").ComputedRef<boolean>;
        states: import("./src/tokens").SelectOptionContext;
        unregister: () => void;
        updateOption: (option: import("./src/tokens").SelectOptionContext) => void;
        optionGroupUnregister: (() => void) | undefined;
        hoverItem: () => void;
        optionKls: import("vue").ComputedRef<string[]>;
        selectOptionClick: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly value: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, null, boolean>;
        readonly disabled: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        readonly label: {
            readonly type: import("vue").PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
        readonly created: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    }>>, {
        readonly disabled: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly value: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
        readonly created: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    }, {}>;
    OptionGroup: import("vue").DefineComponent<{
        readonly label: {
            readonly type: import("vue").PropType<string>;
            readonly required: true;
            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;
        };
        select: import("./src/tokens").SelectContext;
        visible: import("vue").Ref<boolean>;
        options: import("vue").Ref<Map<import("./src/tokens").SelectOptionValue, import("./src/tokens").SelectOptionContext>>;
        optionsArray: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly label: {
            readonly type: import("vue").PropType<string>;
            readonly required: true;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __vsPropKey: true;
        };
    }>>, {}, {}>;
};
export default VsSelect;
export declare const VsOption: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
    readonly value: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, null, boolean>;
    readonly disabled: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly label: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly created: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, 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;
    };
    props: import("@vue/shared").LooseRequired<{
        readonly disabled: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly value: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
        readonly created: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
        readonly label?: string | undefined;
    } & {}>;
    value: import("vue").Ref<import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>>;
    select: import("./src/tokens").SelectContext;
    selectRegister: (option: import("./src/tokens").SelectOptionContext) => {
        unregister: () => void;
        updateOption: (option: import("./src/tokens").SelectOptionContext) => void;
    };
    optionGroupRegister: ((option: import("./src/tokens").SelectOptionContext) => {
        unregister: () => void;
    }) | undefined;
    selectGroup: {
        disabled: boolean;
    };
    el: import("vue").Ref<HTMLElement | undefined>;
    isObject: import("vue").ComputedRef<boolean>;
    limitReached: import("vue").ComputedRef<boolean>;
    currentLabel: import("vue").ComputedRef<string>;
    isDisabled: import("vue").ComputedRef<boolean>;
    isSelected: import("vue").ComputedRef<boolean>;
    states: import("./src/tokens").SelectOptionContext;
    unregister: () => void;
    updateOption: (option: import("./src/tokens").SelectOptionContext) => void;
    optionGroupUnregister: (() => void) | undefined;
    hoverItem: () => void;
    optionKls: import("vue").ComputedRef<string[]>;
    selectOptionClick: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly value: import("vuesax-alpha/es/utils").VsPropFinalized<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown, null, boolean>;
    readonly disabled: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly label: {
        readonly type: import("vue").PropType<string>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
    readonly created: import("vuesax-alpha/es/utils").VsPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
}>>, {
    readonly disabled: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly value: import("vuesax-alpha/es/utils").VsPropMergeType<(new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue) | ((new (...args: any[]) => import("./src/tokens").SelectOptionValue & {}) | (() => import("./src/tokens").SelectOptionValue))[], unknown, unknown>;
    readonly created: import("vuesax-alpha/es/utils").VsPropMergeType<BooleanConstructor, unknown, unknown>;
}, {}>>;
export declare const VsOptionGroup: import("vuesax-alpha/es/utils").SFCWithInstall<import("vue").DefineComponent<{
    readonly label: {
        readonly type: import("vue").PropType<string>;
        readonly required: true;
        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;
    };
    select: import("./src/tokens").SelectContext;
    visible: import("vue").Ref<boolean>;
    options: import("vue").Ref<Map<import("./src/tokens").SelectOptionValue, import("./src/tokens").SelectOptionContext>>;
    optionsArray: import("vue").ComputedRef<import("./src/tokens").SelectOptionContext[]>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly label: {
        readonly type: import("vue").PropType<string>;
        readonly required: true;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __vsPropKey: true;
    };
}>>, {}, {}>>;
export * from './src/option-group';
export * from './src/option';
export * from './src/select';
