npm - ep-craft - Versions diffs - 0.1.30 → 0.1.31 - Mend

ep-craft 0.1.30 → 0.1.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/dist/components/select/index.d.ts CHANGED Viewed

@@ -2,5 +2,2103 @@ import type { Plugin } from 'vue';
 import _EpSelect from './select.vue';
 export declare const EpSelect: typeof _EpSelect & Plugin;
 export default EpSelect;
+export declare const ElSelect: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        ariaLabel: StringConstructor;
+        emptyValues: ArrayConstructor;
+        valueOnClear: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+        floatLabel: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        name: StringConstructor;
+        id: StringConstructor;
+        modelValue: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
+        autocomplete: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        automaticDropdown: BooleanConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        effect: import("../../utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
+        disabled: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        clearable: BooleanConstructor;
+        filterable: BooleanConstructor;
+        allowCreate: BooleanConstructor;
+        loading: BooleanConstructor;
+        popperClass: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        popperStyle: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        popperOptions: import("../../utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
+        remote: BooleanConstructor;
+        debounce: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        loadingText: StringConstructor;
+        noMatchText: StringConstructor;
+        noDataText: StringConstructor;
+        remoteMethod: {
+            readonly type: import("vue").PropType<(query: string) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        filterMethod: {
+            readonly type: import("vue").PropType<(query: string) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        multiple: BooleanConstructor;
+        multipleLimit: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        placeholder: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        defaultFirstOption: BooleanConstructor;
+        reserveKeyword: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        valueKey: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        collapseTags: BooleanConstructor;
+        collapseTagsTooltip: BooleanConstructor;
+        tagTooltip: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("./select").TagTooltipProps) | (() => import("./select").TagTooltipProps) | (((new (...args: any[]) => import("./select").TagTooltipProps) | (() => import("./select").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
+        maxCollapseTags: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        teleported: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        persistent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        clearIcon: import("../../utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+        fitInputWidth: BooleanConstructor;
+        suffixIcon: import("../../utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+        tagType: import("../../utils").EpPropFinalized<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown, string, boolean>;
+        tagEffect: import("../../utils").EpPropFinalized<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown, string, boolean>;
+        validateEvent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        remoteShowSuffix: BooleanConstructor;
+        showArrow: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        offset: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        placement: import("../../utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
+        fallbackPlacements: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
+        tabindex: import("../../utils").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
+        appendTo: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        options: {
+            readonly type: import("vue").PropType<Record<string, any>[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        props: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("../select-v2/src/useProps").Props) | (() => import("../select-v2/src/useProps").Props) | (((new (...args: any[]) => import("../select-v2/src/useProps").Props) | (() => import("../select-v2/src/useProps").Props)) | null)[], unknown, unknown, () => Required<import("../select-v2/src/useProps").Props>, boolean>;
+    }>> & Readonly<{
+        onClear?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
+        onChange?: ((val: any) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+        "onVisible-change"?: ((visible: boolean) => any) | undefined;
+        "onRemove-tag"?: ((val: unknown) => any) | undefined;
+        "onPopup-scroll"?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+    }>, {
+        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
+        selectedLabel: import("vue").ComputedRef<string | string[]>;
+        floatLabelClass: import("vue").ComputedRef<import("../../hooks").FloatLabelClass>;
+        floatLabelText: import("vue").ComputedRef<string>;
+        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+        inputStyle: import("vue").ComputedRef<{
+            minWidth: string;
+        }>;
+        getLabel: (option: import("../select-v2/src/select.types").Option) => any;
+        getValue: (option: import("../select-v2/src/select.types").Option) => any;
+        getOptions: (option: import("../select-v2/src/select.types").Option) => any;
+        getDisabled: (option: import("../select-v2/src/select.types").Option) => any;
+        getOptionProps: (option: Record<string, any>) => {
+            label: any;
+            value: any;
+            disabled: any;
+        };
+        inputId: import("vue").Ref<string | undefined, string | undefined>;
+        contentId: import("vue").Ref<string, string>;
+        nsSelect: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+        };
+        nsInput: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: {
+            inputValue: string;
+            options: Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance> & Omit<Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance>, keyof Map<any, any>>;
+            cachedOptions: Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance> & Omit<Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance>, keyof Map<any, any>>;
+            optionValues: import("./src/type").OptionValue[];
+            selected: {
+                index: number;
+                value: import("./src/type").OptionValue;
+                currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+                isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+            }[];
+            hoveringIndex: number;
+            inputHovering: boolean;
+            selectionWidth: number;
+            collapseItemWidth: number;
+            previousQuery: string | null;
+            selectedLabel: string;
+            menuVisibleOnFocus: boolean;
+            isBeforeHide: boolean;
+        };
+        isFocused: import("vue").Ref<boolean, boolean>;
+        expanded: import("vue").Ref<boolean, boolean>;
+        optionsArray: import("vue").ComputedRef<import("./src/type").OptionPublicInstance[]>;
+        hoverOption: import("vue").Ref<any, any>;
+        selectSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+        filteredOptionsCount: import("vue").ComputedRef<number>;
+        updateTooltip: () => void;
+        updateTagTooltip: () => void;
+        debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
+        onInput: (event: Event) => void;
+        deletePrevTag: (e: KeyboardEvent) => void;
+        deleteTag: (event: MouseEvent, tag: import("./src/type").OptionBasic) => void;
+        deleteSelected: (event: Event) => void;
+        handleOptionSelect: (option: import("./src/type").OptionPublicInstance) => void;
+        scrollToOption: (option: import("./src/type").OptionPublicInstance | import("./src/type").OptionPublicInstance[] | import("./src/type").SelectStates["selected"]) => void;
+        hasModelValue: import("vue").ComputedRef<boolean>;
+        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
+        currentPlaceholder: import("vue").ComputedRef<string>;
+        mouseEnterEventName: string | null;
+        needStatusIcon: import("vue").ComputedRef<boolean>;
+        showClearBtn: import("vue").ComputedRef<boolean>;
+        iconComponent: import("vue").ComputedRef<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        iconReverse: import("vue").ComputedRef<string>;
+        validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+        validateIcon: import("vue").ComputedRef<import("vue").Component | "">;
+        showNewOption: import("vue").ComputedRef<boolean>;
+        updateOptions: () => void;
+        collapseTagSize: import("vue").ComputedRef<"default" | "small">;
+        setSelected: () => void;
+        selectDisabled: import("vue").ComputedRef<boolean>;
+        emptyText: import("vue").ComputedRef<string | null>;
+        handleCompositionStart: (event: CompositionEvent) => void;
+        handleCompositionUpdate: (event: CompositionEvent) => void;
+        handleCompositionEnd: (event: CompositionEvent) => void;
+        handleKeydown: (e: KeyboardEvent) => void;
+        onOptionCreate: (vm: import("./src/type").OptionPublicInstance) => void;
+        onOptionDestroy: (key: import("./src/type").OptionValue, vm: import("./src/type").OptionPublicInstance) => void;
+        handleMenuEnter: () => void;
+        focus: () => void;
+        blur: () => void;
+        handleClearClick: (event: Event) => void;
+        handleClickOutside: (event: Event) => void;
+        handleEsc: () => void;
+        toggleMenu: (event?: Event) => void;
+        selectOption: () => void;
+        getValueKey: (item: import("./src/type").OptionPublicInstance | import("./src/type").SelectStates["selected"][0]) => any;
+        navigateOptions: (direction: "prev" | "next") => void;
+        dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
+        showTagList: import("vue").ComputedRef<{
+            index: number;
+            value: import("./src/type").OptionValue;
+            currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+            isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+        }[]>;
+        collapseTagList: import("vue").ComputedRef<{
+            index: number;
+            value: import("./src/type").OptionValue;
+            currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+            isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+        }[]>;
+        popupScroll: (data: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void;
+        getOption: (value: import("./src/type").OptionValue) => {
+            index: number;
+            value: import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
+            currentLabel: any;
+        } | {
+            index: number;
+            value: import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
+            currentLabel: string | number | boolean;
+            readonly isDisabled: boolean;
+        };
+        endReached: (direction: import("../scrollbar").ScrollbarDirection) => void;
+        tagStyle: import("vue").ComputedRef<{
+            maxWidth: string;
+        }>;
+        collapseTagStyle: import("vue").ComputedRef<{
+            maxWidth: string;
+        }>;
+        popperRef: import("vue").ComputedRef<HTMLElement | undefined>;
+        inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        tooltipRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+        tagTooltipRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+        prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+        selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrollbarRef: import("vue").Ref<import("../scrollbar").ScrollbarInstance | undefined, import("../scrollbar").ScrollbarInstance | undefined>;
+        menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: import("./select").SelectProps["modelValue"] | any) => boolean;
+        change: (val: import("./select").SelectProps["modelValue"] | any) => boolean;
+        'popup-scroll': ({ scrollTop, scrollLeft, }: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => boolean;
+        'end-reached': (direction: import("../scrollbar").ScrollbarDirection) => boolean;
+        'remove-tag': (val: unknown) => boolean;
+        'visible-change': (visible: boolean) => boolean;
+        focus: (evt: FocusEvent) => boolean;
+        blur: (evt: FocusEvent) => boolean;
+        clear: () => boolean;
+    }, import("vue").PublicProps, {
+        props: import("../select-v2/src/useProps").Props;
+        offset: number;
+        multiple: boolean;
+        disabled: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        tabindex: import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
+        teleported: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        loading: boolean;
+        placement: import("../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
+        effect: import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>;
+        modelValue: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
+        valueOnClear: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
+        floatLabel: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        autocomplete: string;
+        clearable: boolean;
+        clearIcon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
+        suffixIcon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
+        validateEvent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        popperClass: string;
+        fallbackPlacements: import("element-plus").Placement[];
+        popperOptions: Partial<import("element-plus").Options>;
+        showArrow: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        persistent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        valueKey: string;
+        debounce: number;
+        fitInputWidth: boolean;
+        filterable: boolean;
+        collapseTags: boolean;
+        maxCollapseTags: number;
+        collapseTagsTooltip: boolean;
+        tagType: import("../../utils").EpPropMergeType<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown>;
+        tagEffect: import("../../utils").EpPropMergeType<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown>;
+        automaticDropdown: boolean;
+        tagTooltip: import("./select").TagTooltipProps;
+        multipleLimit: number;
+        reserveKeyword: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        allowCreate: boolean;
+        defaultFirstOption: boolean;
+        remote: boolean;
+        remoteShowSuffix: boolean;
+    }, true, {}, {}, {
+        ElSelectMenu: import("vue").DefineComponent<{}, {
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+            };
+            minWidth: import("vue").Ref<string, string>;
+            popperClass: import("vue").ComputedRef<string>;
+            isMultiple: import("vue").ComputedRef<boolean>;
+            isFitInputWidth: import("vue").ComputedRef<boolean>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            value: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            label: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            created: BooleanConstructor;
+            disabled: BooleanConstructor;
+        }>, {
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+            };
+            id: import("vue").Ref<string, string>;
+            containerKls: import("vue").ComputedRef<string[]>;
+            currentLabel: import("vue").ComputedRef<boolean | import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
+            itemSelected: import("vue").ComputedRef<boolean>;
+            isDisabled: import("vue").ComputedRef<boolean>;
+            select: import("./src/type").SelectContext;
+            visible: import("vue").Ref<boolean, boolean>;
+            hover: import("vue").Ref<boolean, boolean>;
+            states: {
+                index: number;
+                groupDisabled: boolean;
+                visible: boolean;
+                hover: boolean;
+            };
+            mouseMoveEventName: "mousemove" | null;
+            hoverItem: () => void;
+            handleMousedown: (event: MouseEvent) => void;
+            updateOption: (query: string) => void;
+            selectOptionClick: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            value: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            label: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            created: BooleanConstructor;
+            disabled: BooleanConstructor;
+        }>> & Readonly<{}>, {
+            created: boolean;
+            disabled: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElOptions: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElOptionGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            label: StringConstructor;
+            disabled: BooleanConstructor;
+        }>, {
+            groupRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            visible: import("vue").ComputedRef<boolean>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            label: StringConstructor;
+            disabled: BooleanConstructor;
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElTag: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                readonly type: {
+                    readonly type: import("vue").PropType<typeof import("../tag").tagTypes[number]>;
+                    readonly values: readonly ["primary", "success", "info", "warning", "danger"];
+                    readonly default: "primary";
+                };
+                readonly closable: BooleanConstructor;
+                readonly disableTransitions: BooleanConstructor;
+                readonly hit: BooleanConstructor;
+                readonly color: StringConstructor;
+                readonly size: {
+                    readonly type: import("vue").PropType<"" | "large" | "default" | "small">;
+                    readonly values: readonly ["", "large", "default", "small"];
+                };
+                readonly effect: {
+                    readonly type: import("vue").PropType<typeof import("../tag").tagEffects[number]>;
+                    readonly values: readonly ["dark", "light", "plain"];
+                    readonly default: "light";
+                };
+                readonly round: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+                onClose?: ((evt: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+                close: (evt: MouseEvent) => void;
+            }, import("vue").PublicProps, {
+                readonly round: boolean;
+                readonly type: "primary" | "success" | "warning" | "info" | "danger";
+                readonly effect: "dark" | "light" | "plain";
+                readonly closable: boolean;
+                readonly disableTransitions: boolean;
+                readonly hit: boolean;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                readonly type: {
+                    readonly type: import("vue").PropType<typeof import("../tag").tagTypes[number]>;
+                    readonly values: readonly ["primary", "success", "info", "warning", "danger"];
+                    readonly default: "primary";
+                };
+                readonly closable: BooleanConstructor;
+                readonly disableTransitions: BooleanConstructor;
+                readonly hit: BooleanConstructor;
+                readonly color: StringConstructor;
+                readonly size: {
+                    readonly type: import("vue").PropType<"" | "large" | "default" | "small">;
+                    readonly values: readonly ["", "large", "default", "small"];
+                };
+                readonly effect: {
+                    readonly type: import("vue").PropType<typeof import("../tag").tagEffects[number]>;
+                    readonly values: readonly ["dark", "light", "plain"];
+                    readonly default: "light";
+                };
+                readonly round: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+                onClose?: ((evt: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, {
+                readonly round: boolean;
+                readonly type: "primary" | "success" | "warning" | "info" | "danger";
+                readonly effect: "dark" | "light" | "plain";
+                readonly closable: boolean;
+                readonly disableTransitions: boolean;
+                readonly hit: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly type: {
+                readonly type: import("vue").PropType<typeof import("../tag").tagTypes[number]>;
+                readonly values: readonly ["primary", "success", "info", "warning", "danger"];
+                readonly default: "primary";
+            };
+            readonly closable: BooleanConstructor;
+            readonly disableTransitions: BooleanConstructor;
+            readonly hit: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<"" | "large" | "default" | "small">;
+                readonly values: readonly ["", "large", "default", "small"];
+            };
+            readonly effect: {
+                readonly type: import("vue").PropType<typeof import("../tag").tagEffects[number]>;
+                readonly values: readonly ["dark", "light", "plain"];
+                readonly default: "light";
+            };
+            readonly round: BooleanConstructor;
+        }>> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+            onClose?: ((evt: MouseEvent) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+            close: (evt: MouseEvent) => void;
+        }, string, {
+            readonly round: boolean;
+            readonly type: "primary" | "success" | "warning" | "info" | "danger";
+            readonly effect: "dark" | "light" | "plain";
+            readonly closable: boolean;
+            readonly disableTransitions: boolean;
+            readonly hit: boolean;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            };
+        }) & Plugin;
+        ElScrollbar: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+            }>, {
+                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
+            }, import("vue").PublicProps, {
+                tag: keyof HTMLElementTagNameMap | (string & {});
+                tabindex: number | string;
+                height: number | string;
+                maxHeight: number | string;
+                distance: number;
+                wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                wrapClass: string | string[];
+                viewClass: string | string[];
+                viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                minSize: number;
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("element-plus").ScrollbarProps> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+            }>, {
+                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, {}, {}, {}, {
+                tag: keyof HTMLElementTagNameMap | (string & {});
+                tabindex: number | string;
+                height: number | string;
+                maxHeight: number | string;
+                distance: number;
+                wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                wrapClass: string | string[];
+                viewClass: string | string[];
+                viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                minSize: number;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
+        }, string, {
+            tag: keyof HTMLElementTagNameMap | (string & {});
+            tabindex: number | string;
+            height: number | string;
+            maxHeight: number | string;
+            distance: number;
+            wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            wrapClass: string | string[];
+            viewClass: string | string[];
+            viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            minSize: number;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").ObjectPlugin & {
+            setPropsDefaults: (defaults: {
+                readonly distance?: number | (() => number) | undefined;
+                readonly height?: string | number | (() => string | number) | undefined;
+                readonly maxHeight?: string | number | (() => string | number) | undefined;
+                readonly native?: boolean | (() => boolean) | undefined;
+                readonly wrapStyle?: string | false | (() => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | null | undefined;
+                readonly wrapClass?: string | (() => string | string[]) | undefined;
+                readonly viewClass?: string | (() => string | string[]) | undefined;
+                readonly viewStyle?: string | false | (() => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | null | undefined;
+                readonly noresize?: boolean | (() => boolean) | undefined;
+                readonly tag?: (string & {}) | keyof HTMLElementTagNameMap | (() => string) | undefined;
+                readonly always?: boolean | (() => boolean) | undefined;
+                readonly minSize?: number | (() => number) | undefined;
+                readonly tabindex?: string | number | (() => string | number) | undefined;
+                readonly id?: string | (() => string) | undefined;
+                readonly role?: string | (() => string) | undefined;
+                readonly ariaLabel?: string | (() => string) | undefined;
+                readonly ariaOrientation?: "undefined" | "horizontal" | "vertical" | (() => "undefined" | "horizontal" | "vertical") | undefined;
+            }) => void;
+        } & Plugin;
+        ElTooltip: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                onOpen?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+                contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                hide: (...args: any[]) => void;
+                show: (...args: any[]) => void;
+                open: (...args: any[]) => void;
+                close: (...args: any[]) => void;
+                "update:visible": (...args: any[]) => void;
+                "before-show": (...args: any[]) => void;
+                "before-hide": (...args: any[]) => void;
+            }, import("vue").PublicProps, {
+                content: string;
+                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                visible: boolean | null;
+                offset: number;
+                teleported: boolean;
+                placement: import("element-plus").Placement;
+                strategy: "fixed" | "absolute";
+                effect: import("../popper").PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                role: typeof import("../popper").roleTypes[number];
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                virtualTriggering: boolean;
+                loop: boolean;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                popperOptions: Partial<import("element-plus").Options>;
+                arrowOffset: number;
+                showArrow: boolean;
+                trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+                triggerKeys: string[];
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                onOpen?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+                contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, {
+                content: string;
+                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                visible: boolean | null;
+                offset: number;
+                teleported: boolean;
+                placement: import("element-plus").Placement;
+                strategy: "fixed" | "absolute";
+                effect: import("../popper").PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                role: typeof import("../popper").roleTypes[number];
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                virtualTriggering: boolean;
+                loop: boolean;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                popperOptions: Partial<import("element-plus").Options>;
+                arrowOffset: number;
+                showArrow: boolean;
+                trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+                triggerKeys: string[];
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+            contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            open: (...args: any[]) => void;
+            close: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, string, {
+            content: string;
+            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            placement: import("element-plus").Placement;
+            strategy: "fixed" | "absolute";
+            effect: import("../popper").PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            role: typeof import("../popper").roleTypes[number];
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            popperOptions: Partial<import("element-plus").Options>;
+            arrowOffset: number;
+            showArrow: boolean;
+            trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+            triggerKeys: string[];
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                content?: (props: {}) => any;
+            };
+        }) & Plugin;
+        ElIcon: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & Plugin;
+    } & import("vue").GlobalComponents, {
+        ClickOutside: import("vue").ObjectDirective<HTMLElement, any, string, any>;
+    } & import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        ariaLabel: StringConstructor;
+        emptyValues: ArrayConstructor;
+        valueOnClear: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+        floatLabel: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        name: StringConstructor;
+        id: StringConstructor;
+        modelValue: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
+        autocomplete: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        automaticDropdown: BooleanConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        effect: import("../../utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
+        disabled: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        clearable: BooleanConstructor;
+        filterable: BooleanConstructor;
+        allowCreate: BooleanConstructor;
+        loading: BooleanConstructor;
+        popperClass: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        popperStyle: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        popperOptions: import("../../utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
+        remote: BooleanConstructor;
+        debounce: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        loadingText: StringConstructor;
+        noMatchText: StringConstructor;
+        noDataText: StringConstructor;
+        remoteMethod: {
+            readonly type: import("vue").PropType<(query: string) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        filterMethod: {
+            readonly type: import("vue").PropType<(query: string) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        multiple: BooleanConstructor;
+        multipleLimit: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        placeholder: {
+            readonly type: import("vue").PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        defaultFirstOption: BooleanConstructor;
+        reserveKeyword: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        valueKey: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+        collapseTags: BooleanConstructor;
+        collapseTagsTooltip: BooleanConstructor;
+        tagTooltip: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("./select").TagTooltipProps) | (() => import("./select").TagTooltipProps) | (((new (...args: any[]) => import("./select").TagTooltipProps) | (() => import("./select").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
+        maxCollapseTags: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        teleported: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        persistent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        clearIcon: import("../../utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+        fitInputWidth: BooleanConstructor;
+        suffixIcon: import("../../utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+        tagType: import("../../utils").EpPropFinalized<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown, string, boolean>;
+        tagEffect: import("../../utils").EpPropFinalized<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown, string, boolean>;
+        validateEvent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        remoteShowSuffix: BooleanConstructor;
+        showArrow: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        offset: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+        placement: import("../../utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
+        fallbackPlacements: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
+        tabindex: import("../../utils").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
+        appendTo: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        options: {
+            readonly type: import("vue").PropType<Record<string, any>[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        props: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("../select-v2/src/useProps").Props) | (() => import("../select-v2/src/useProps").Props) | (((new (...args: any[]) => import("../select-v2/src/useProps").Props) | (() => import("../select-v2/src/useProps").Props)) | null)[], unknown, unknown, () => Required<import("../select-v2/src/useProps").Props>, boolean>;
+    }>> & Readonly<{
+        onClear?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((val: any) => any) | undefined;
+        onChange?: ((val: any) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+        "onVisible-change"?: ((visible: boolean) => any) | undefined;
+        "onRemove-tag"?: ((val: unknown) => any) | undefined;
+        "onPopup-scroll"?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+    }>, {
+        modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
+        selectedLabel: import("vue").ComputedRef<string | string[]>;
+        floatLabelClass: import("vue").ComputedRef<import("../../hooks").FloatLabelClass>;
+        floatLabelText: import("vue").ComputedRef<string>;
+        calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+        inputStyle: import("vue").ComputedRef<{
+            minWidth: string;
+        }>;
+        getLabel: (option: import("../select-v2/src/select.types").Option) => any;
+        getValue: (option: import("../select-v2/src/select.types").Option) => any;
+        getOptions: (option: import("../select-v2/src/select.types").Option) => any;
+        getDisabled: (option: import("../select-v2/src/select.types").Option) => any;
+        getOptionProps: (option: Record<string, any>) => {
+            label: any;
+            value: any;
+            disabled: any;
+        };
+        inputId: import("vue").Ref<string | undefined, string | undefined>;
+        contentId: import("vue").Ref<string, string>;
+        nsSelect: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+        };
+        nsInput: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: {
+            inputValue: string;
+            options: Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance> & Omit<Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance>, keyof Map<any, any>>;
+            cachedOptions: Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance> & Omit<Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance>, keyof Map<any, any>>;
+            optionValues: import("./src/type").OptionValue[];
+            selected: {
+                index: number;
+                value: import("./src/type").OptionValue;
+                currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+                isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+            }[];
+            hoveringIndex: number;
+            inputHovering: boolean;
+            selectionWidth: number;
+            collapseItemWidth: number;
+            previousQuery: string | null;
+            selectedLabel: string;
+            menuVisibleOnFocus: boolean;
+            isBeforeHide: boolean;
+        };
+        isFocused: import("vue").Ref<boolean, boolean>;
+        expanded: import("vue").Ref<boolean, boolean>;
+        optionsArray: import("vue").ComputedRef<import("./src/type").OptionPublicInstance[]>;
+        hoverOption: import("vue").Ref<any, any>;
+        selectSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+        filteredOptionsCount: import("vue").ComputedRef<number>;
+        updateTooltip: () => void;
+        updateTagTooltip: () => void;
+        debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
+        onInput: (event: Event) => void;
+        deletePrevTag: (e: KeyboardEvent) => void;
+        deleteTag: (event: MouseEvent, tag: import("./src/type").OptionBasic) => void;
+        deleteSelected: (event: Event) => void;
+        handleOptionSelect: (option: import("./src/type").OptionPublicInstance) => void;
+        scrollToOption: (option: import("./src/type").OptionPublicInstance | import("./src/type").OptionPublicInstance[] | import("./src/type").SelectStates["selected"]) => void;
+        hasModelValue: import("vue").ComputedRef<boolean>;
+        shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
+        currentPlaceholder: import("vue").ComputedRef<string>;
+        mouseEnterEventName: string | null;
+        needStatusIcon: import("vue").ComputedRef<boolean>;
+        showClearBtn: import("vue").ComputedRef<boolean>;
+        iconComponent: import("vue").ComputedRef<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        iconReverse: import("vue").ComputedRef<string>;
+        validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+        validateIcon: import("vue").ComputedRef<import("vue").Component | "">;
+        showNewOption: import("vue").ComputedRef<boolean>;
+        updateOptions: () => void;
+        collapseTagSize: import("vue").ComputedRef<"default" | "small">;
+        setSelected: () => void;
+        selectDisabled: import("vue").ComputedRef<boolean>;
+        emptyText: import("vue").ComputedRef<string | null>;
+        handleCompositionStart: (event: CompositionEvent) => void;
+        handleCompositionUpdate: (event: CompositionEvent) => void;
+        handleCompositionEnd: (event: CompositionEvent) => void;
+        handleKeydown: (e: KeyboardEvent) => void;
+        onOptionCreate: (vm: import("./src/type").OptionPublicInstance) => void;
+        onOptionDestroy: (key: import("./src/type").OptionValue, vm: import("./src/type").OptionPublicInstance) => void;
+        handleMenuEnter: () => void;
+        focus: () => void;
+        blur: () => void;
+        handleClearClick: (event: Event) => void;
+        handleClickOutside: (event: Event) => void;
+        handleEsc: () => void;
+        toggleMenu: (event?: Event) => void;
+        selectOption: () => void;
+        getValueKey: (item: import("./src/type").OptionPublicInstance | import("./src/type").SelectStates["selected"][0]) => any;
+        navigateOptions: (direction: "prev" | "next") => void;
+        dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
+        showTagList: import("vue").ComputedRef<{
+            index: number;
+            value: import("./src/type").OptionValue;
+            currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+            isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+        }[]>;
+        collapseTagList: import("vue").ComputedRef<{
+            index: number;
+            value: import("./src/type").OptionValue;
+            currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+            isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+        }[]>;
+        popupScroll: (data: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void;
+        getOption: (value: import("./src/type").OptionValue) => {
+            index: number;
+            value: import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
+            currentLabel: any;
+        } | {
+            index: number;
+            value: import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
+            currentLabel: string | number | boolean;
+            readonly isDisabled: boolean;
+        };
+        endReached: (direction: import("../scrollbar").ScrollbarDirection) => void;
+        tagStyle: import("vue").ComputedRef<{
+            maxWidth: string;
+        }>;
+        collapseTagStyle: import("vue").ComputedRef<{
+            maxWidth: string;
+        }>;
+        popperRef: import("vue").ComputedRef<HTMLElement | undefined>;
+        inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        tooltipRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+        tagTooltipRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+        prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+        selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        scrollbarRef: import("vue").Ref<import("../scrollbar").ScrollbarInstance | undefined, import("../scrollbar").ScrollbarInstance | undefined>;
+        menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }, {}, {}, {}, {
+        props: import("../select-v2/src/useProps").Props;
+        offset: number;
+        multiple: boolean;
+        disabled: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        tabindex: import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
+        teleported: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        loading: boolean;
+        placement: import("../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
+        effect: import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>;
+        modelValue: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
+        valueOnClear: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
+        floatLabel: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        autocomplete: string;
+        clearable: boolean;
+        clearIcon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
+        suffixIcon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
+        validateEvent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        popperClass: string;
+        fallbackPlacements: import("element-plus").Placement[];
+        popperOptions: Partial<import("element-plus").Options>;
+        showArrow: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        persistent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        valueKey: string;
+        debounce: number;
+        fitInputWidth: boolean;
+        filterable: boolean;
+        collapseTags: boolean;
+        maxCollapseTags: number;
+        collapseTagsTooltip: boolean;
+        tagType: import("../../utils").EpPropMergeType<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown>;
+        tagEffect: import("../../utils").EpPropMergeType<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown>;
+        automaticDropdown: boolean;
+        tagTooltip: import("./select").TagTooltipProps;
+        multipleLimit: number;
+        reserveKeyword: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        allowCreate: boolean;
+        defaultFirstOption: boolean;
+        remote: boolean;
+        remoteShowSuffix: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    ariaLabel: StringConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+    floatLabel: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    name: StringConstructor;
+    id: StringConstructor;
+    modelValue: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown, undefined, boolean>;
+    autocomplete: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    automaticDropdown: BooleanConstructor;
+    size: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: import("../../utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown, string, boolean>;
+    disabled: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    allowCreate: BooleanConstructor;
+    loading: BooleanConstructor;
+    popperClass: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    popperStyle: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties) | (((new (...args: any[]) => string | import("vue").CSSProperties) | (() => string | import("vue").CSSProperties)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    popperOptions: import("../../utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => Partial<import("element-plus").Options>, boolean>;
+    remote: BooleanConstructor;
+    debounce: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    loadingText: StringConstructor;
+    noMatchText: StringConstructor;
+    noDataText: StringConstructor;
+    remoteMethod: {
+        readonly type: import("vue").PropType<(query: string) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    filterMethod: {
+        readonly type: import("vue").PropType<(query: string) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    multiple: BooleanConstructor;
+    multipleLimit: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placeholder: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultFirstOption: BooleanConstructor;
+    reserveKeyword: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    valueKey: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    collapseTags: BooleanConstructor;
+    collapseTagsTooltip: BooleanConstructor;
+    tagTooltip: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("./select").TagTooltipProps) | (() => import("./select").TagTooltipProps) | (((new (...args: any[]) => import("./select").TagTooltipProps) | (() => import("./select").TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
+    maxCollapseTags: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    teleported: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    persistent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    clearIcon: import("../../utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+    fitInputWidth: BooleanConstructor;
+    suffixIcon: import("../../utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+    tagType: import("../../utils").EpPropFinalized<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown, string, boolean>;
+    tagEffect: import("../../utils").EpPropFinalized<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown, string, boolean>;
+    validateEvent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    remoteShowSuffix: BooleanConstructor;
+    showArrow: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    offset: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placement: import("../../utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown, string, boolean>;
+    fallbackPlacements: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[]) | (((new (...args: any[]) => import("element-plus").Placement[]) | (() => import("element-plus").Placement[])) | null)[], unknown, unknown, string[], boolean>;
+    tabindex: import("../../utils").EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
+    appendTo: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: {
+        readonly type: import("vue").PropType<Record<string, any>[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    props: import("../../utils").EpPropFinalized<(new (...args: any[]) => import("../select-v2/src/useProps").Props) | (() => import("../select-v2/src/useProps").Props) | (((new (...args: any[]) => import("../select-v2/src/useProps").Props) | (() => import("../select-v2/src/useProps").Props)) | null)[], unknown, unknown, () => Required<import("../select-v2/src/useProps").Props>, boolean>;
+}>> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((val: any) => any) | undefined;
+    onChange?: ((val: any) => any) | undefined;
+    onFocus?: ((evt: FocusEvent) => any) | undefined;
+    onBlur?: ((evt: FocusEvent) => any) | undefined;
+    "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+    "onRemove-tag"?: ((val: unknown) => any) | undefined;
+    "onPopup-scroll"?: ((args_0: {
+        scrollTop: number;
+        scrollLeft: number;
+    }) => any) | undefined;
+}>, {
+    modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
+    selectedLabel: import("vue").ComputedRef<string | string[]>;
+    floatLabelClass: import("vue").ComputedRef<import("../../hooks").FloatLabelClass>;
+    floatLabelText: import("vue").ComputedRef<string>;
+    calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+    inputStyle: import("vue").ComputedRef<{
+        minWidth: string;
+    }>;
+    getLabel: (option: import("../select-v2/src/select.types").Option) => any;
+    getValue: (option: import("../select-v2/src/select.types").Option) => any;
+    getOptions: (option: import("../select-v2/src/select.types").Option) => any;
+    getDisabled: (option: import("../select-v2/src/select.types").Option) => any;
+    getOptionProps: (option: Record<string, any>) => {
+        label: any;
+        value: any;
+        disabled: any;
+    };
+    inputId: import("vue").Ref<string | undefined, string | undefined>;
+    contentId: import("vue").Ref<string, string>;
+    nsSelect: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+    };
+    nsInput: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: {
+        inputValue: string;
+        options: Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance> & Omit<Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance>, keyof Map<any, any>>;
+        cachedOptions: Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance> & Omit<Map<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>, import("./src/type").OptionPublicInstance>, keyof Map<any, any>>;
+        optionValues: import("./src/type").OptionValue[];
+        selected: {
+            index: number;
+            value: import("./src/type").OptionValue;
+            currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+            isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+        }[];
+        hoveringIndex: number;
+        inputHovering: boolean;
+        selectionWidth: number;
+        collapseItemWidth: number;
+        previousQuery: string | null;
+        selectedLabel: string;
+        menuVisibleOnFocus: boolean;
+        isBeforeHide: boolean;
+    };
+    isFocused: import("vue").Ref<boolean, boolean>;
+    expanded: import("vue").Ref<boolean, boolean>;
+    optionsArray: import("vue").ComputedRef<import("./src/type").OptionPublicInstance[]>;
+    hoverOption: import("vue").Ref<any, any>;
+    selectSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+    filteredOptionsCount: import("vue").ComputedRef<number>;
+    updateTooltip: () => void;
+    updateTagTooltip: () => void;
+    debouncedOnInputChange: import("@vueuse/core").UseDebounceFnReturn<() => void>;
+    onInput: (event: Event) => void;
+    deletePrevTag: (e: KeyboardEvent) => void;
+    deleteTag: (event: MouseEvent, tag: import("./src/type").OptionBasic) => void;
+    deleteSelected: (event: Event) => void;
+    handleOptionSelect: (option: import("./src/type").OptionPublicInstance) => void;
+    scrollToOption: (option: import("./src/type").OptionPublicInstance | import("./src/type").OptionPublicInstance[] | import("./src/type").SelectStates["selected"]) => void;
+    hasModelValue: import("vue").ComputedRef<boolean>;
+    shouldShowPlaceholder: import("vue").ComputedRef<boolean>;
+    currentPlaceholder: import("vue").ComputedRef<string>;
+    mouseEnterEventName: string | null;
+    needStatusIcon: import("vue").ComputedRef<boolean>;
+    showClearBtn: import("vue").ComputedRef<boolean>;
+    iconComponent: import("vue").ComputedRef<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+    iconReverse: import("vue").ComputedRef<string>;
+    validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+    validateIcon: import("vue").ComputedRef<import("vue").Component | "">;
+    showNewOption: import("vue").ComputedRef<boolean>;
+    updateOptions: () => void;
+    collapseTagSize: import("vue").ComputedRef<"default" | "small">;
+    setSelected: () => void;
+    selectDisabled: import("vue").ComputedRef<boolean>;
+    emptyText: import("vue").ComputedRef<string | null>;
+    handleCompositionStart: (event: CompositionEvent) => void;
+    handleCompositionUpdate: (event: CompositionEvent) => void;
+    handleCompositionEnd: (event: CompositionEvent) => void;
+    handleKeydown: (e: KeyboardEvent) => void;
+    onOptionCreate: (vm: import("./src/type").OptionPublicInstance) => void;
+    onOptionDestroy: (key: import("./src/type").OptionValue, vm: import("./src/type").OptionPublicInstance) => void;
+    handleMenuEnter: () => void;
+    focus: () => void;
+    blur: () => void;
+    handleClearClick: (event: Event) => void;
+    handleClickOutside: (event: Event) => void;
+    handleEsc: () => void;
+    toggleMenu: (event?: Event) => void;
+    selectOption: () => void;
+    getValueKey: (item: import("./src/type").OptionPublicInstance | import("./src/type").SelectStates["selected"][0]) => any;
+    navigateOptions: (direction: "prev" | "next") => void;
+    dropdownMenuVisible: import("vue").WritableComputedRef<boolean, boolean>;
+    showTagList: import("vue").ComputedRef<{
+        index: number;
+        value: import("./src/type").OptionValue;
+        currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+        isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+    }[]>;
+    collapseTagList: import("vue").ComputedRef<{
+        index: number;
+        value: import("./src/type").OptionValue;
+        currentLabel: import("./src/type").OptionPublicInstance["currentLabel"];
+        isDisabled?: import("./src/type").OptionPublicInstance["isDisabled"] | undefined;
+    }[]>;
+    popupScroll: (data: {
+        scrollTop: number;
+        scrollLeft: number;
+    }) => void;
+    getOption: (value: import("./src/type").OptionValue) => {
+        index: number;
+        value: import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
+        currentLabel: any;
+    } | {
+        index: number;
+        value: import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>;
+        currentLabel: string | number | boolean;
+        readonly isDisabled: boolean;
+    };
+    endReached: (direction: import("../scrollbar").ScrollbarDirection) => void;
+    tagStyle: import("vue").ComputedRef<{
+        maxWidth: string;
+    }>;
+    collapseTagStyle: import("vue").ComputedRef<{
+        maxWidth: string;
+    }>;
+    popperRef: import("vue").ComputedRef<HTMLElement | undefined>;
+    inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    tooltipRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+    tagTooltipRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+    prefixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    suffixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    selectRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    wrapperRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
+    selectionRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    scrollbarRef: import("vue").Ref<import("../scrollbar").ScrollbarInstance | undefined, import("../scrollbar").ScrollbarInstance | undefined>;
+    menuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    tagMenuRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    collapseItemRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (val: import("./select").SelectProps["modelValue"] | any) => boolean;
+    change: (val: import("./select").SelectProps["modelValue"] | any) => boolean;
+    'popup-scroll': ({ scrollTop, scrollLeft, }: {
+        scrollTop: number;
+        scrollLeft: number;
+    }) => boolean;
+    'end-reached': (direction: import("../scrollbar").ScrollbarDirection) => boolean;
+    'remove-tag': (val: unknown) => boolean;
+    'visible-change': (visible: boolean) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+}, string, {
+    props: import("../select-v2/src/useProps").Props;
+    offset: number;
+    multiple: boolean;
+    disabled: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    tabindex: import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>;
+    teleported: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    loading: boolean;
+    placement: import("../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], import("element-plus").Placement, unknown>;
+    effect: import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>;
+    modelValue: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null) | (((new (...args: any[]) => string | number | boolean | Record<string, any> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[]) | (() => import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown> | import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>[] | null)) | null)[], unknown, unknown>;
+    valueOnClear: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
+    floatLabel: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    autocomplete: string;
+    clearable: boolean;
+    clearIcon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
+    suffixIcon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>;
+    validateEvent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    popperClass: string;
+    fallbackPlacements: import("element-plus").Placement[];
+    popperOptions: Partial<import("element-plus").Options>;
+    showArrow: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    persistent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    valueKey: string;
+    debounce: number;
+    fitInputWidth: boolean;
+    filterable: boolean;
+    collapseTags: boolean;
+    maxCollapseTags: number;
+    collapseTagsTooltip: boolean;
+    tagType: import("../../utils").EpPropMergeType<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown>;
+    tagEffect: import("../../utils").EpPropMergeType<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown>;
+    automaticDropdown: boolean;
+    tagTooltip: import("./select").TagTooltipProps;
+    multipleLimit: number;
+    reserveKeyword: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    allowCreate: boolean;
+    defaultFirstOption: boolean;
+    remote: boolean;
+    remoteShowSuffix: boolean;
+}, {}, string, {}, {
+    ElSelectMenu: import("vue").DefineComponent<{}, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+        };
+        minWidth: import("vue").Ref<string, string>;
+        popperClass: import("vue").ComputedRef<string>;
+        isMultiple: import("vue").ComputedRef<boolean>;
+        isFitInputWidth: import("vue").ComputedRef<boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        value: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        label: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        created: BooleanConstructor;
+        disabled: BooleanConstructor;
+    }>, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+        };
+        id: import("vue").Ref<string, string>;
+        containerKls: import("vue").ComputedRef<string[]>;
+        currentLabel: import("vue").ComputedRef<boolean | import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
+        itemSelected: import("vue").ComputedRef<boolean>;
+        isDisabled: import("vue").ComputedRef<boolean>;
+        select: import("./src/type").SelectContext;
+        visible: import("vue").Ref<boolean, boolean>;
+        hover: import("vue").Ref<boolean, boolean>;
+        states: {
+            index: number;
+            groupDisabled: boolean;
+            visible: boolean;
+            hover: boolean;
+        };
+        mouseMoveEventName: "mousemove" | null;
+        hoverItem: () => void;
+        handleMousedown: (event: MouseEvent) => void;
+        updateOption: (query: string) => void;
+        selectOptionClick: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        value: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        label: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(NumberConstructor | StringConstructor)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        created: BooleanConstructor;
+        disabled: BooleanConstructor;
+    }>> & Readonly<{}>, {
+        created: boolean;
+        disabled: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElOptions: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElOptionGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        label: StringConstructor;
+        disabled: BooleanConstructor;
+    }>, {
+        groupRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        visible: import("vue").ComputedRef<boolean>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        label: StringConstructor;
+        disabled: BooleanConstructor;
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElTag: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            readonly type: {
+                readonly type: import("vue").PropType<typeof import("../tag").tagTypes[number]>;
+                readonly values: readonly ["primary", "success", "info", "warning", "danger"];
+                readonly default: "primary";
+            };
+            readonly closable: BooleanConstructor;
+            readonly disableTransitions: BooleanConstructor;
+            readonly hit: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<"" | "large" | "default" | "small">;
+                readonly values: readonly ["", "large", "default", "small"];
+            };
+            readonly effect: {
+                readonly type: import("vue").PropType<typeof import("../tag").tagEffects[number]>;
+                readonly values: readonly ["dark", "light", "plain"];
+                readonly default: "light";
+            };
+            readonly round: BooleanConstructor;
+        }>> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+            onClose?: ((evt: MouseEvent) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+            close: (evt: MouseEvent) => void;
+        }, import("vue").PublicProps, {
+            readonly round: boolean;
+            readonly type: "primary" | "success" | "warning" | "info" | "danger";
+            readonly effect: "dark" | "light" | "plain";
+            readonly closable: boolean;
+            readonly disableTransitions: boolean;
+            readonly hit: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            readonly type: {
+                readonly type: import("vue").PropType<typeof import("../tag").tagTypes[number]>;
+                readonly values: readonly ["primary", "success", "info", "warning", "danger"];
+                readonly default: "primary";
+            };
+            readonly closable: BooleanConstructor;
+            readonly disableTransitions: BooleanConstructor;
+            readonly hit: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<"" | "large" | "default" | "small">;
+                readonly values: readonly ["", "large", "default", "small"];
+            };
+            readonly effect: {
+                readonly type: import("vue").PropType<typeof import("../tag").tagEffects[number]>;
+                readonly values: readonly ["dark", "light", "plain"];
+                readonly default: "light";
+            };
+            readonly round: BooleanConstructor;
+        }>> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+            onClose?: ((evt: MouseEvent) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            readonly round: boolean;
+            readonly type: "primary" | "success" | "warning" | "info" | "danger";
+            readonly effect: "dark" | "light" | "plain";
+            readonly closable: boolean;
+            readonly disableTransitions: boolean;
+            readonly hit: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        readonly type: {
+            readonly type: import("vue").PropType<typeof import("../tag").tagTypes[number]>;
+            readonly values: readonly ["primary", "success", "info", "warning", "danger"];
+            readonly default: "primary";
+        };
+        readonly closable: BooleanConstructor;
+        readonly disableTransitions: BooleanConstructor;
+        readonly hit: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly size: {
+            readonly type: import("vue").PropType<"" | "large" | "default" | "small">;
+            readonly values: readonly ["", "large", "default", "small"];
+        };
+        readonly effect: {
+            readonly type: import("vue").PropType<typeof import("../tag").tagEffects[number]>;
+            readonly values: readonly ["dark", "light", "plain"];
+            readonly default: "light";
+        };
+        readonly round: BooleanConstructor;
+    }>> & Readonly<{
+        onClick?: ((evt: MouseEvent) => any) | undefined;
+        onClose?: ((evt: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (evt: MouseEvent) => void;
+        close: (evt: MouseEvent) => void;
+    }, string, {
+        readonly round: boolean;
+        readonly type: "primary" | "success" | "warning" | "info" | "danger";
+        readonly effect: "dark" | "light" | "plain";
+        readonly closable: boolean;
+        readonly disableTransitions: boolean;
+        readonly hit: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            default?: (props: {}) => any;
+        };
+    }) & Plugin;
+    ElScrollbar: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
+        }, import("vue").PublicProps, {
+            tag: keyof HTMLElementTagNameMap | (string & {});
+            tabindex: number | string;
+            height: number | string;
+            maxHeight: number | string;
+            distance: number;
+            wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            wrapClass: string | string[];
+            viewClass: string | string[];
+            viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            minSize: number;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("element-plus").ScrollbarProps> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, {}, {}, {}, {
+            tag: keyof HTMLElementTagNameMap | (string & {});
+            tabindex: number | string;
+            height: number | string;
+            maxHeight: number | string;
+            distance: number;
+            wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            wrapClass: string | string[];
+            viewClass: string | string[];
+            viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            minSize: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("element-plus").ScrollbarProps> & Readonly<{
+        onScroll?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+        "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+    }>, {
+        wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+        update: () => void;
+        scrollTo: {
+            (xCord: number, yCord?: number): void;
+            (options: ScrollToOptions): void;
+        };
+        setScrollTop: (value: number) => void;
+        setScrollLeft: (value: number) => void;
+        handleScroll: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        scroll: (args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void;
+        "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
+    }, string, {
+        tag: keyof HTMLElementTagNameMap | (string & {});
+        tabindex: number | string;
+        height: number | string;
+        maxHeight: number | string;
+        distance: number;
+        wrapStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        wrapClass: string | string[];
+        viewClass: string | string[];
+        viewStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        minSize: number;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) & import("vue").ObjectPlugin & {
+        setPropsDefaults: (defaults: {
+            readonly distance?: number | (() => number) | undefined;
+            readonly height?: string | number | (() => string | number) | undefined;
+            readonly maxHeight?: string | number | (() => string | number) | undefined;
+            readonly native?: boolean | (() => boolean) | undefined;
+            readonly wrapStyle?: string | false | (() => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | null | undefined;
+            readonly wrapClass?: string | (() => string | string[]) | undefined;
+            readonly viewClass?: string | (() => string | string[]) | undefined;
+            readonly viewStyle?: string | false | (() => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | null | undefined;
+            readonly noresize?: boolean | (() => boolean) | undefined;
+            readonly tag?: (string & {}) | keyof HTMLElementTagNameMap | (() => string) | undefined;
+            readonly always?: boolean | (() => boolean) | undefined;
+            readonly minSize?: number | (() => number) | undefined;
+            readonly tabindex?: string | number | (() => string | number) | undefined;
+            readonly id?: string | (() => string) | undefined;
+            readonly role?: string | (() => string) | undefined;
+            readonly ariaLabel?: string | (() => string) | undefined;
+            readonly ariaOrientation?: "undefined" | "horizontal" | "vertical" | (() => "undefined" | "horizontal" | "vertical") | undefined;
+        }) => void;
+    } & Plugin;
+    ElTooltip: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+            contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            open: (...args: any[]) => void;
+            close: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, import("vue").PublicProps, {
+            content: string;
+            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            placement: import("element-plus").Placement;
+            strategy: "fixed" | "absolute";
+            effect: import("../popper").PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            role: typeof import("../popper").roleTypes[number];
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            popperOptions: Partial<import("element-plus").Options>;
+            arrowOffset: number;
+            showArrow: boolean;
+            trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+            triggerKeys: string[];
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+            contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, {
+            content: string;
+            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            placement: import("element-plus").Placement;
+            strategy: "fixed" | "absolute";
+            effect: import("../popper").PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            role: typeof import("../popper").roleTypes[number];
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            popperOptions: Partial<import("element-plus").Options>;
+            arrowOffset: number;
+            showArrow: boolean;
+            trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+            triggerKeys: string[];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+        onHide?: ((...args: any[]) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onClose?: ((...args: any[]) => any) | undefined;
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+        "onBefore-show"?: ((...args: any[]) => any) | undefined;
+        "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+        contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+        updatePopper: () => void;
+        onOpen: (event?: Event, delay?: number) => void;
+        onClose: (event?: Event, delay?: number) => void;
+        hide: (event?: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        hide: (...args: any[]) => void;
+        show: (...args: any[]) => void;
+        open: (...args: any[]) => void;
+        close: (...args: any[]) => void;
+        "update:visible": (...args: any[]) => void;
+        "before-show": (...args: any[]) => void;
+        "before-hide": (...args: any[]) => void;
+    }, string, {
+        content: string;
+        style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        visible: boolean | null;
+        offset: number;
+        teleported: boolean;
+        placement: import("element-plus").Placement;
+        strategy: "fixed" | "absolute";
+        effect: import("../popper").PopperEffect;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        role: typeof import("../popper").roleTypes[number];
+        enterable: boolean;
+        pure: boolean;
+        focusOnShow: boolean;
+        trapping: boolean;
+        popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        stopPopperMouseEvent: boolean;
+        virtualTriggering: boolean;
+        loop: boolean;
+        boundariesPadding: number;
+        gpuAcceleration: boolean;
+        popperOptions: Partial<import("element-plus").Options>;
+        arrowOffset: number;
+        showArrow: boolean;
+        trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+        triggerKeys: string[];
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            content?: (props: {}) => any;
+        };
+    }) & Plugin;
+    ElIcon: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) & Plugin;
+} & import("vue").GlobalComponents, {
+    ClickOutside: import("vue").ObjectDirective<HTMLElement, any, string, any>;
+} & import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Plugin;
+export { EpOption as ElOption } from '../option';
 export { selectEmits, selectProps } from './select';
 export type { SelectEmits, SelectInstance, SelectOptionProps, SelectProps, SelectPropsPublic, TagTooltipProps, } from './select';