yuang-framework-ui-pc 1.1.44 → 1.1.45

package/es/ele-edit-tag/index.d.ts

@@ -0,0 +1,2380 @@
+import { ElTagInstance, ElInputInstance } from '../ele-app/el';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: import('vue').PropType<string[]>;
+    type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
+    hit: BooleanConstructor;
+    color: StringConstructor;
+    size: import('vue').PropType<import('../ele-app/el').ElTagProps["size"]>;
+    effect: import('vue').PropType<import('../ele-app/el').ElTagProps["effect"]>;
+    round: BooleanConstructor;
+    placeholder: StringConstructor;
+    inputStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    inputTagStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    buttonStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    validator: import('vue').PropType<import('./types').Validator>;
+    beforeRemove: import('vue').PropType<import('./types').BeforeRemove>;
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>, {
+    inputTagRef: import('vue').Ref<ElTagInstance, ElTagInstance>;
+    inputRef: import('vue').Ref<ElInputInstance, ElInputInstance>;
+    isEdit: import('vue').Ref<boolean, boolean>;
+    inputValue: import('vue').Ref<string, string>;
+    errorMessage: import('vue').Ref<string, string>;
+    loading: import('vue').Ref<boolean, boolean>;
+    tooltipVisible: import('vue').Ref<boolean, boolean>;
+    updateInputValue: (value: string) => void;
+    handleAddClick: () => void;
+    handleTagClose: (index: number) => void;
+    handleInputChange: () => void;
+    handleInputBlur: () => void;
+    handleInputFocus: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value?: string[]) => boolean;
+    change: (_value?: string[]) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: import('vue').PropType<string[]>;
+    type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
+    hit: BooleanConstructor;
+    color: StringConstructor;
+    size: import('vue').PropType<import('../ele-app/el').ElTagProps["size"]>;
+    effect: import('vue').PropType<import('../ele-app/el').ElTagProps["effect"]>;
+    round: BooleanConstructor;
+    placeholder: StringConstructor;
+    inputStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    inputTagStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    buttonStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    validator: import('vue').PropType<import('./types').Validator>;
+    beforeRemove: import('vue').PropType<import('./types').BeforeRemove>;
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    onChange?: ((_value?: string[] | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value?: string[] | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    round: boolean;
+    readonly: boolean;
+    hit: boolean;
+}, {}, {
+    ElTag: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly type: {
+                readonly type: import('vue').PropType<"success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "primary";
+            };
+            readonly closable: BooleanConstructor;
+            readonly disableTransitions: BooleanConstructor;
+            readonly hit: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly effect: {
+                readonly type: import('vue').PropType<"dark" | "light" | "plain">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "light";
+            };
+            readonly round: BooleanConstructor;
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+            onClose?: ((evt: MouseEvent) => any) | undefined;
+        }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+            close: (evt: MouseEvent) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly round: boolean;
+            readonly type: "success" | "primary" | "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<"success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "primary";
+            };
+            readonly closable: BooleanConstructor;
+            readonly disableTransitions: BooleanConstructor;
+            readonly hit: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly effect: {
+                readonly type: import('vue').PropType<"dark" | "light" | "plain">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "light";
+            };
+            readonly round: BooleanConstructor;
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+            onClose?: ((evt: MouseEvent) => any) | undefined;
+        }, {}, {}, {}, {}, {
+            readonly round: boolean;
+            readonly type: "success" | "primary" | "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<"success" | "primary" | "warning" | "info" | "danger">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "primary";
+        };
+        readonly closable: BooleanConstructor;
+        readonly disableTransitions: BooleanConstructor;
+        readonly hit: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly size: {
+            readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly effect: {
+            readonly type: import('vue').PropType<"dark" | "light" | "plain">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "light";
+        };
+        readonly round: BooleanConstructor;
+    }>> & {
+        onClick?: ((evt: MouseEvent) => any) | undefined;
+        onClose?: ((evt: MouseEvent) => any) | undefined;
+    }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (evt: MouseEvent) => void;
+        close: (evt: MouseEvent) => void;
+    }, string, {
+        readonly round: boolean;
+        readonly type: "success" | "primary" | "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?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+    ElInput: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly id: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly modelValue: {
+                readonly type: import('vue').PropType<string | number | null | undefined>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxlength: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly minlength: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "text";
+            };
+            readonly resize: {
+                readonly type: import('vue').PropType<"horizontal" | "vertical" | "none" | "both">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly autosize: {
+                readonly type: import('vue').PropType<import('element-plus').InputAutoSize>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly autocomplete: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "off";
+            };
+            readonly formatter: {
+                readonly type: import('vue').PropType<Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly parser: {
+                readonly type: import('vue').PropType<Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly placeholder: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly form: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly readonly: BooleanConstructor;
+            readonly clearable: BooleanConstructor;
+            readonly showPassword: BooleanConstructor;
+            readonly showWordLimit: BooleanConstructor;
+            readonly suffixIcon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly prefixIcon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly containerRole: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tabindex: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly validateEvent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly inputStyle: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly autofocus: BooleanConstructor;
+            readonly rows: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 2;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onChange?: ((value: string) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+        }, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined>;
+            ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+            textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+            autosize: import('vue').Ref<import('element-plus').InputAutoSize>;
+            isComposing: import('vue').Ref<boolean>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: () => void;
+            resizeTextarea: () => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            input: (value: string) => void;
+            clear: () => void;
+            "update:modelValue": (value: string) => void;
+            change: (value: string) => void;
+            blur: (evt: FocusEvent) => void;
+            compositionend: (evt: CompositionEvent) => void;
+            compositionstart: (evt: CompositionEvent) => void;
+            compositionupdate: (evt: CompositionEvent) => void;
+            focus: (evt: FocusEvent) => void;
+            keydown: (evt: Event | KeyboardEvent) => void;
+            mouseenter: (evt: MouseEvent) => void;
+            mouseleave: (evt: MouseEvent) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly disabled: boolean;
+            readonly id: string;
+            readonly type: string;
+            readonly modelValue: string | number | null | undefined;
+            readonly tabindex: string | number;
+            readonly readonly: boolean;
+            readonly autosize: import('element-plus').InputAutoSize;
+            readonly autocomplete: string;
+            readonly containerRole: string;
+            readonly validateEvent: boolean;
+            readonly inputStyle: import('vue').StyleValue;
+            readonly rows: number;
+            readonly clearable: boolean;
+            readonly showPassword: boolean;
+            readonly showWordLimit: boolean;
+            readonly autofocus: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly id: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly modelValue: {
+                readonly type: import('vue').PropType<string | number | null | undefined>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxlength: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly minlength: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "text";
+            };
+            readonly resize: {
+                readonly type: import('vue').PropType<"horizontal" | "vertical" | "none" | "both">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly autosize: {
+                readonly type: import('vue').PropType<import('element-plus').InputAutoSize>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly autocomplete: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "off";
+            };
+            readonly formatter: {
+                readonly type: import('vue').PropType<Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly parser: {
+                readonly type: import('vue').PropType<Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly placeholder: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly form: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly readonly: BooleanConstructor;
+            readonly clearable: BooleanConstructor;
+            readonly showPassword: BooleanConstructor;
+            readonly showWordLimit: BooleanConstructor;
+            readonly suffixIcon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly prefixIcon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly containerRole: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tabindex: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly validateEvent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly inputStyle: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            readonly autofocus: BooleanConstructor;
+            readonly rows: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 2;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onChange?: ((value: string) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+        }, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined>;
+            ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+            textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+            autosize: import('vue').Ref<import('element-plus').InputAutoSize>;
+            isComposing: import('vue').Ref<boolean>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: () => void;
+            resizeTextarea: () => void;
+        }, {}, {}, {}, {
+            readonly disabled: boolean;
+            readonly id: string;
+            readonly type: string;
+            readonly modelValue: string | number | null | undefined;
+            readonly tabindex: string | number;
+            readonly readonly: boolean;
+            readonly autosize: import('element-plus').InputAutoSize;
+            readonly autocomplete: string;
+            readonly containerRole: string;
+            readonly validateEvent: boolean;
+            readonly inputStyle: import('vue').StyleValue;
+            readonly rows: number;
+            readonly clearable: boolean;
+            readonly showPassword: boolean;
+            readonly showWordLimit: boolean;
+            readonly autofocus: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly ariaLabel: StringConstructor;
+        readonly id: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly size: {
+            readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly modelValue: {
+            readonly type: import('vue').PropType<string | number | null | undefined>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly maxlength: {
+            readonly type: import('vue').PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly minlength: {
+            readonly type: import('vue').PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "text";
+        };
+        readonly resize: {
+            readonly type: import('vue').PropType<"horizontal" | "vertical" | "none" | "both">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly autosize: {
+            readonly type: import('vue').PropType<import('element-plus').InputAutoSize>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: false;
+        };
+        readonly autocomplete: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "off";
+        };
+        readonly formatter: {
+            readonly type: import('vue').PropType<Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly parser: {
+            readonly type: import('vue').PropType<Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly placeholder: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly form: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly readonly: BooleanConstructor;
+        readonly clearable: BooleanConstructor;
+        readonly showPassword: BooleanConstructor;
+        readonly showWordLimit: BooleanConstructor;
+        readonly suffixIcon: {
+            readonly type: import('vue').PropType<string | import('vue').Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly prefixIcon: {
+            readonly type: import('vue').PropType<string | import('vue').Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly containerRole: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly tabindex: {
+            readonly type: import('vue').PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly validateEvent: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly inputStyle: {
+            readonly type: import('vue').PropType<import('vue').StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        readonly autofocus: BooleanConstructor;
+        readonly rows: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 2;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
+        onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+        onClear?: (() => any) | undefined;
+    }, {
+        input: import('vue').ShallowRef<HTMLInputElement | undefined>;
+        textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined>;
+        ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+        textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+        autosize: import('vue').Ref<import('element-plus').InputAutoSize>;
+        isComposing: import('vue').Ref<boolean>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void;
+        clear: () => void;
+        resizeTextarea: () => void;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        input: (value: string) => void;
+        clear: () => void;
+        "update:modelValue": (value: string) => void;
+        change: (value: string) => void;
+        blur: (evt: FocusEvent) => void;
+        compositionend: (evt: CompositionEvent) => void;
+        compositionstart: (evt: CompositionEvent) => void;
+        compositionupdate: (evt: CompositionEvent) => void;
+        focus: (evt: FocusEvent) => void;
+        keydown: (evt: Event | KeyboardEvent) => void;
+        mouseenter: (evt: MouseEvent) => void;
+        mouseleave: (evt: MouseEvent) => void;
+    }, string, {
+        readonly disabled: boolean;
+        readonly id: string;
+        readonly type: string;
+        readonly modelValue: string | number | null | undefined;
+        readonly tabindex: string | number;
+        readonly readonly: boolean;
+        readonly autosize: import('element-plus').InputAutoSize;
+        readonly autocomplete: string;
+        readonly containerRole: string;
+        readonly validateEvent: boolean;
+        readonly inputStyle: import('vue').StyleValue;
+        readonly rows: number;
+        readonly clearable: boolean;
+        readonly showPassword: boolean;
+        readonly showWordLimit: boolean;
+        readonly autofocus: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            prepend?(_: {}): any;
+            prefix?(_: {}): any;
+            suffix?(_: {}): any;
+            append?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+    ElIcon: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly size: {
+            readonly type: import('vue').PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly color: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+    EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+        bg: StringConstructor;
+        arrowBg: StringConstructor;
+        width: (StringConstructor | NumberConstructor)[];
+        isPopover: BooleanConstructor;
+        showAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        hideAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 200;
+        };
+        autoClose: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        effect: {
+            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "dark";
+        };
+        ariaLabel: StringConstructor;
+        placement: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        teleported: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        appendTo: {
+            readonly type: import('vue').PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        disabled: BooleanConstructor;
+        offset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 12;
+        };
+        persistent: BooleanConstructor;
+        zIndex: NumberConstructor;
+        visible: {
+            readonly type: import('vue').PropType<boolean | null>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: null;
+        };
+        trigger: {
+            readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        triggerKeys: {
+            readonly type: import('vue').PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        popperOptions: {
+            readonly type: import('vue').PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        transition: StringConstructor;
+        content: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        enterable: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        showArrow: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        arrowOffset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 5;
+        };
+        virtualRef: {
+            readonly type: import('vue').PropType<import('element-plus').Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        virtualTriggering: BooleanConstructor;
+        rawContent: BooleanConstructor;
+        gpuAcceleration: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        className: StringConstructor;
+        popperClass: StringConstructor;
+        popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    }>, {
+        tooltipRef: import('vue').Ref<import('../ele-app/el').ElTooltipInstance | undefined, import('../ele-app/el').ElTooltipInstance | undefined>;
+        rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
+        popperRef: import('vue').ComputedRef<import('../ele-app/el').ElPopperInstance>;
+        contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
+        isFocusInsideContent: () => void;
+        updatePopper: () => void;
+        handleOpen: (opt?: Event) => void;
+        handleClose: (opt?: Event) => void;
+        hide: (opt?: Event) => void;
+        handleUpdateVisible: (visible: boolean) => void;
+        handlePopBeforeShow: (e: Event) => void;
+        handlePopBeforeHide: (e: Event) => void;
+        handlePopShow: (e: Event) => void;
+        handlePopHide: (e: Event) => void;
+        handlePopOpen: (e: any) => void;
+        handlePopClose: (e: any) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+        bg: StringConstructor;
+        arrowBg: StringConstructor;
+        width: (StringConstructor | NumberConstructor)[];
+        isPopover: BooleanConstructor;
+        showAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        hideAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 200;
+        };
+        autoClose: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        effect: {
+            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "dark";
+        };
+        ariaLabel: StringConstructor;
+        placement: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        teleported: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        appendTo: {
+            readonly type: import('vue').PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        disabled: BooleanConstructor;
+        offset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 12;
+        };
+        persistent: BooleanConstructor;
+        zIndex: NumberConstructor;
+        visible: {
+            readonly type: import('vue').PropType<boolean | null>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: null;
+        };
+        trigger: {
+            readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        triggerKeys: {
+            readonly type: import('vue').PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        popperOptions: {
+            readonly type: import('vue').PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        transition: StringConstructor;
+        content: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        enterable: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        showArrow: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        arrowOffset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 5;
+        };
+        virtualRef: {
+            readonly type: import('vue').PropType<import('element-plus').Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        virtualTriggering: BooleanConstructor;
+        rawContent: BooleanConstructor;
+        gpuAcceleration: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        className: StringConstructor;
+        popperClass: StringConstructor;
+        popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    }>> & Readonly<{
+        onClose?: ((e: any) => any) | undefined;
+        onHide?: ((e: Event) => any) | undefined;
+        onOpen?: ((e: any) => any) | undefined;
+        "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+        "onBefore-show"?: ((e: Event) => any) | undefined;
+        "onBefore-hide"?: ((e: Event) => any) | undefined;
+        onShow?: ((e: Event) => any) | undefined;
+    }>, {
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        effect: import('element-plus').PopperEffect;
+        placement: string;
+        teleported: boolean;
+        disabled: boolean;
+        offset: number;
+        persistent: boolean;
+        visible: boolean | null;
+        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+        triggerKeys: string[];
+        popperOptions: any;
+        content: string;
+        enterable: boolean;
+        showArrow: boolean;
+        arrowOffset: number;
+        virtualTriggering: boolean;
+        rawContent: boolean;
+        gpuAcceleration: boolean;
+        isPopover: boolean;
+    }, {}, {
+        ElTooltip: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: import('vue').PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: import('vue').PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: import('vue').PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: import('vue').PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: import('vue').PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: import('vue').PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                [x: string]: (...args: any[]) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: import('vue').PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: import('vue').PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: import('vue').PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: import('vue').PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: import('vue').PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: import('vue').PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            showArrow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            disabled: BooleanConstructor;
+            trigger: {
+                readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: import('vue').PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            virtualRef: {
+                readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            onMouseenter: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            id: StringConstructor;
+            open: BooleanConstructor;
+            ariaLabel: StringConstructor;
+            appendTo: {
+                readonly type: import('vue').PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            content: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            rawContent: BooleanConstructor;
+            persistent: BooleanConstructor;
+            visible: {
+                readonly type: import('vue').PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            transition: StringConstructor;
+            teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            style: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            className: {
+                readonly type: import('vue').PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            effect: {
+                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            enterable: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            pure: BooleanConstructor;
+            focusOnShow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            trapping: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            popperClass: {
+                readonly type: import('vue').PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            popperStyle: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            referenceEl: {
+                readonly type: import('vue').PropType<HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            triggerTargetEl: {
+                readonly type: import('vue').PropType<HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            stopPopperMouseEvent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            zIndex: NumberConstructor;
+            boundariesPadding: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            fallbackPlacements: {
+                readonly type: import('vue').PropType<Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            gpuAcceleration: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            offset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            placement: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            popperOptions: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            strategy: {
+                readonly type: import('vue').PropType<"fixed" | "absolute">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "absolute";
+            };
+            showAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            "onUpdate:visible": {
+                readonly type: import('vue').PropType<(val: boolean) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            role: {
+                readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "tooltip";
+            };
+        }>>, {
+            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event) => void;
+            onClose: (event?: Event) => void;
+            hide: (event?: Event) => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            [x: string]: (...args: any[]) => void;
+        }, string, {
+            disabled: boolean;
+            content: string;
+            offset: number;
+            visible: boolean | null;
+            open: boolean;
+            placement: string;
+            strategy: "fixed" | "absolute";
+            effect: import('element-plus').PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+            virtualTriggering: boolean;
+            arrowOffset: number;
+            boundariesPadding: number;
+            fallbackPlacements: Placement[];
+            gpuAcceleration: boolean;
+            popperOptions: Partial<Options>;
+            enterable: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            stopPopperMouseEvent: boolean;
+            pure: boolean;
+            triggerKeys: string[];
+            teleported: boolean;
+            rawContent: boolean;
+            persistent: boolean;
+            showArrow: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+                content?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    PlusOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    LoadingOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;