npm - sd-render - Versions diffs - 1.0.24 → 1.0.26 - Mend

sd-render 1.0.24 → 1.0.26

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

Files changed (34) hide show

package/types/src/components/input3/eltiptap/widget/MenuCommands/HighlightPopover.vue.d.ts CHANGED Viewed

@@ -22,934 +22,267 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         required: true;
     };
 }>> & Readonly<{}>, {}, {}, {
-    ElButton: ({
-        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-            readonly size: {
-                readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly disabled: BooleanConstructor;
-            readonly type: {
-                readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly icon: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly nativeType: {
-                readonly type: import('vue').PropType<"button" | "reset" | "submit">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "button";
-            };
-            readonly loading: BooleanConstructor;
-            readonly loadingIcon: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: () => any;
-            };
-            readonly plain: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly text: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly link: BooleanConstructor;
-            readonly bg: BooleanConstructor;
-            readonly autofocus: BooleanConstructor;
-            readonly round: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly circle: BooleanConstructor;
-            readonly color: StringConstructor;
-            readonly dark: BooleanConstructor;
-            readonly autoInsertSpace: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly tag: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "button";
-            };
-        }>> & {
+    ElButton: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
             onClick?: ((evt: MouseEvent) => any) | undefined;
-        }, {
-            ref: import('vue').Ref<HTMLButtonElement | undefined>;
-            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
-            type: import('vue').ComputedRef<string>;
+        }>, {
+            ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "default" | "large" | "small">;
+            type: import('vue').ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
             disabled: import('vue').ComputedRef<boolean>;
             shouldAddSpace: import('vue').ComputedRef<boolean>;
-        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             click: (evt: MouseEvent) => void;
-        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
-            readonly link: boolean;
-            readonly circle: boolean;
-            readonly text: boolean;
-            readonly disabled: boolean;
-            readonly round: boolean;
-            readonly dark: boolean;
-            readonly type: "" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger";
-            readonly bg: boolean;
-            readonly loading: boolean;
-            readonly autofocus: boolean;
-            readonly tag: string | import('vue').Component;
-            readonly plain: boolean;
-            readonly autoInsertSpace: boolean;
-            readonly nativeType: "button" | "reset" | "submit";
-            readonly loadingIcon: string | import('vue').Component;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        }, import('vue').PublicProps, {
+            type: import('element-plus').ButtonType;
+            disabled: boolean;
+            text: boolean;
+            round: boolean;
+            dashed: boolean;
+            plain: boolean;
+            nativeType: import('element-plus').ButtonNativeType;
+            loadingIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            autoInsertSpace: boolean;
+            tag: string | import('vue').Component;
+        }, false, {}, {}, 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<"" | "default" | "small" | "large">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly disabled: BooleanConstructor;
-            readonly type: {
-                readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly icon: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly nativeType: {
-                readonly type: import('vue').PropType<"button" | "reset" | "submit">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "button";
-            };
-            readonly loading: BooleanConstructor;
-            readonly loadingIcon: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: () => any;
-            };
-            readonly plain: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly text: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly link: BooleanConstructor;
-            readonly bg: BooleanConstructor;
-            readonly autofocus: BooleanConstructor;
-            readonly round: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly circle: BooleanConstructor;
-            readonly color: StringConstructor;
-            readonly dark: BooleanConstructor;
-            readonly autoInsertSpace: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly tag: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "button";
-            };
-        }>> & {
+        }, Readonly<import('element-plus').ButtonProps> & Readonly<{
             onClick?: ((evt: MouseEvent) => any) | undefined;
-        }, {
-            ref: import('vue').Ref<HTMLButtonElement | undefined>;
-            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
-            type: import('vue').ComputedRef<string>;
+        }>, {
+            ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "default" | "large" | "small">;
+            type: import('vue').ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
             disabled: import('vue').ComputedRef<boolean>;
             shouldAddSpace: import('vue').ComputedRef<boolean>;
         }, {}, {}, {}, {
-            readonly link: boolean;
-            readonly circle: boolean;
-            readonly text: boolean;
-            readonly disabled: boolean;
-            readonly round: boolean;
-            readonly dark: boolean;
-            readonly type: "" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger";
-            readonly bg: boolean;
-            readonly loading: boolean;
-            readonly autofocus: boolean;
-            readonly tag: string | import('vue').Component;
-            readonly plain: boolean;
-            readonly autoInsertSpace: boolean;
-            readonly nativeType: "button" | "reset" | "submit";
-            readonly loadingIcon: string | import('vue').Component;
+            type: import('element-plus').ButtonType;
+            disabled: boolean;
+            text: boolean;
+            round: boolean;
+            dashed: boolean;
+            plain: boolean;
+            nativeType: import('element-plus').ButtonNativeType;
+            loadingIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            autoInsertSpace: boolean;
+            tag: string | import('vue').Component;
         }>;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
-        readonly size: {
-            readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        readonly disabled: BooleanConstructor;
-        readonly type: {
-            readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: "";
-        };
-        readonly icon: {
-            readonly type: import('vue').PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        readonly nativeType: {
-            readonly type: import('vue').PropType<"button" | "reset" | "submit">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: "button";
-        };
-        readonly loading: BooleanConstructor;
-        readonly loadingIcon: {
-            readonly type: import('vue').PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => any;
-        };
-        readonly plain: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly text: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly link: BooleanConstructor;
-        readonly bg: BooleanConstructor;
-        readonly autofocus: BooleanConstructor;
-        readonly round: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly circle: BooleanConstructor;
-        readonly color: StringConstructor;
-        readonly dark: BooleanConstructor;
-        readonly autoInsertSpace: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly tag: {
-            readonly type: import('vue').PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: "button";
-        };
-    }>> & {
+    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
         onClick?: ((evt: MouseEvent) => any) | undefined;
-    }, {
-        ref: import('vue').Ref<HTMLButtonElement | undefined>;
-        size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
-        type: import('vue').ComputedRef<string>;
+    }>, {
+        ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+        size: import('vue').ComputedRef<"" | "default" | "large" | "small">;
+        type: import('vue').ComputedRef<"default" | "" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
         disabled: import('vue').ComputedRef<boolean>;
         shouldAddSpace: import('vue').ComputedRef<boolean>;
-    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         click: (evt: MouseEvent) => void;
     }, string, {
-        readonly link: boolean;
-        readonly circle: boolean;
-        readonly text: boolean;
-        readonly disabled: boolean;
-        readonly round: boolean;
-        readonly dark: boolean;
-        readonly type: "" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger";
-        readonly bg: boolean;
-        readonly loading: boolean;
-        readonly autofocus: boolean;
-        readonly tag: string | import('vue').Component;
-        readonly plain: boolean;
-        readonly autoInsertSpace: boolean;
-        readonly nativeType: "button" | "reset" | "submit";
-        readonly loadingIcon: string | import('vue').Component;
+        type: import('element-plus').ButtonType;
+        disabled: boolean;
+        text: boolean;
+        round: boolean;
+        dashed: boolean;
+        plain: boolean;
+        nativeType: import('element-plus').ButtonNativeType;
+        loadingIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+        autoInsertSpace: boolean;
+        tag: string | import('vue').Component;
     }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
         $slots: {
-            loading?(_: {}): any;
-            icon?(_: {}): any;
-            default?(_: {}): any;
-        };
-    }) & import('vue').Plugin) & {
+            loading?: (props: {}) => any;
+        } & {
+            icon?: (props: {}) => any;
+        } & {
+            default?: (props: {}) => any;
+        };
+    }) & import('vue').ObjectPlugin & {
+        setPropsDefaults: (defaults: Partial<{
+            readonly size?: import('element-plus').ComponentSize | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly type?: import('element-plus').ButtonType | undefined;
+            readonly icon?: import('element-plus/es/utils/index.mjs').IconPropType | undefined;
+            readonly nativeType?: import('element-plus').ButtonNativeType | undefined;
+            readonly loading?: boolean | undefined;
+            readonly loadingIcon?: import('element-plus/es/utils/index.mjs').IconPropType | undefined;
+            readonly plain?: boolean | undefined;
+            readonly text?: boolean | undefined;
+            readonly link?: boolean | undefined;
+            readonly bg?: boolean | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly round?: boolean | undefined;
+            readonly circle?: boolean | undefined;
+            readonly dashed?: boolean | undefined;
+            readonly color?: string | undefined;
+            readonly dark?: boolean | undefined;
+            readonly autoInsertSpace?: boolean | undefined;
+            readonly tag?: (string | import('vue').Component) | undefined;
+            readonly onClick?: ((evt: MouseEvent) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps>) => void;
+    } & {
         ButtonGroup: {
-            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-                readonly size: {
-                    readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                };
-                readonly type: {
-                    readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger">;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                } & {
-                    readonly default: "";
-                };
-            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
-                readonly type: "" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger";
-            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                direction: "horizontal" | "vertical";
+            }, false, {}, {}, 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<"" | "default" | "small" | "large">;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                };
-                readonly type: {
-                    readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger">;
-                    readonly required: false;
-                    readonly validator: ((val: unknown) => boolean) | undefined;
-                    __epPropKey: true;
-                } & {
-                    readonly default: "";
-                };
-            }>>, {}, {}, {}, {}, {
-                readonly type: "" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger";
+            }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                direction: "horizontal" | "vertical";
             }>;
             __isFragment?: never;
             __isTeleport?: never;
             __isSuspense?: never;
-        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
-            readonly size: {
-                readonly type: import('vue').PropType<"" | "default" | "small" | "large">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly type: {
-                readonly type: import('vue').PropType<"" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
-            readonly type: "" | "default" | "text" | "primary" | "success" | "info" | "warning" | "danger";
+        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+            direction: "horizontal" | "vertical";
         }, {}, 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?: (props: {}) => any;
             };
         });
     };
-    ElPopover: ({
-        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-            readonly 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";
-            };
-            readonly triggerKeys: {
-                readonly type: import('vue').PropType<string[]>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: () => string[];
-            };
-            readonly placement: {
-                readonly type: import('vue').PropType<any>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "bottom";
-            };
-            readonly disabled: BooleanConstructor;
-            readonly visible: {
-                readonly type: import('vue').PropType<boolean | null>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: null;
-            };
-            readonly transition: StringConstructor;
-            readonly popperOptions: {
-                readonly type: import('vue').PropType<any>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: () => {};
-            };
-            readonly tabindex: {
-                readonly type: import('vue').PropType<string | number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 0;
-            };
-            readonly content: {
-                readonly type: import('vue').PropType<string>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly popperStyle: {
-                readonly type: import('vue').PropType<import('vue').StyleValue>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly 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;
-            };
-            readonly enterable: {
-                readonly default: true;
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                readonly __epPropKey: true;
-            };
-            readonly effect: {
-                readonly default: "light";
-                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                readonly __epPropKey: true;
-            };
-            readonly teleported: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
-            };
-            readonly appendTo: {
-                readonly type: import('vue').PropType<string | HTMLElement>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly title: StringConstructor;
-            readonly width: {
-                readonly type: import('vue').PropType<string | number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 150;
-            };
-            readonly offset: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly showAfter: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 0;
-            };
-            readonly hideAfter: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 200;
-            };
-            readonly autoClose: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 0;
-            };
-            readonly showArrow: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
-            };
-            readonly persistent: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
-            };
-            readonly "onUpdate:visible": {
-                readonly type: import('vue').PropType<(visible: boolean) => void>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-        }>> & {
+    ElPopover: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').PopoverProps> & Readonly<{
             "onUpdate:visible"?: ((value: boolean) => any) | undefined;
-            "onAfter-enter"?: (() => any) | undefined;
-            "onAfter-leave"?: (() => any) | undefined;
             "onBefore-enter"?: (() => any) | undefined;
             "onBefore-leave"?: (() => any) | undefined;
-        }, {
+            "onAfter-enter"?: (() => any) | undefined;
+            "onAfter-leave"?: (() => any) | undefined;
+        }>, {
             popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
             hide: () => void;
-        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            "after-enter": () => void;
-            "after-leave": () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:visible": (value: boolean) => void;
             "before-enter": () => void;
             "before-leave": () => void;
-            "update:visible": (value: boolean) => void;
-        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
-            readonly disabled: boolean;
-            readonly tabindex: string | number;
-            readonly width: string | number;
-            readonly content: string;
-            readonly offset: number;
-            readonly visible: boolean | null;
-            readonly placement: any;
-            readonly effect: import('element-plus').PopperEffect;
-            readonly showAfter: number;
-            readonly hideAfter: number;
-            readonly autoClose: number;
-            readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
-            readonly popperOptions: Partial<Options>;
-            readonly enterable: boolean;
-            readonly triggerKeys: string[];
-            readonly teleported: boolean;
-            readonly persistent: boolean;
-            readonly showArrow: boolean;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            "after-enter": () => void;
+            "after-leave": () => void;
+        }, import('vue').PublicProps, {
+            effect: import('element-plus').PopperEffect;
+            placement: Placement;
+            popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            teleported: boolean;
+            persistent: boolean;
+            visible: boolean | null;
+            enterable: boolean;
+            offset: number;
+            popperOptions: Partial<Options>;
+            showArrow: boolean;
+            content: string;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            triggerKeys: string[];
+            width: string | number;
+            tabindex: string | number;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
             C: {};
             M: {};
             Defaults: {};
-        }, Readonly<import('vue').ExtractPropTypes<{
-            readonly 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";
-            };
-            readonly triggerKeys: {
-                readonly type: import('vue').PropType<string[]>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: () => string[];
-            };
-            readonly placement: {
-                readonly type: import('vue').PropType<any>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "bottom";
-            };
-            readonly disabled: BooleanConstructor;
-            readonly visible: {
-                readonly type: import('vue').PropType<boolean | null>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: null;
-            };
-            readonly transition: StringConstructor;
-            readonly popperOptions: {
-                readonly type: import('vue').PropType<any>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: () => {};
-            };
-            readonly tabindex: {
-                readonly type: import('vue').PropType<string | number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 0;
-            };
-            readonly content: {
-                readonly type: import('vue').PropType<string>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly popperStyle: {
-                readonly type: import('vue').PropType<import('vue').StyleValue>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly 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;
-            };
-            readonly enterable: {
-                readonly default: true;
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                readonly __epPropKey: true;
-            };
-            readonly effect: {
-                readonly default: "light";
-                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                readonly __epPropKey: true;
-            };
-            readonly teleported: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
-            };
-            readonly appendTo: {
-                readonly type: import('vue').PropType<string | HTMLElement>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly title: StringConstructor;
-            readonly width: {
-                readonly type: import('vue').PropType<string | number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 150;
-            };
-            readonly offset: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly showAfter: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 0;
-            };
-            readonly hideAfter: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 200;
-            };
-            readonly autoClose: {
-                readonly type: import('vue').PropType<number>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: 0;
-            };
-            readonly showArrow: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
-            };
-            readonly persistent: {
-                readonly type: import('vue').PropType<boolean>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
-            };
-            readonly "onUpdate:visible": {
-                readonly type: import('vue').PropType<(visible: boolean) => void>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-        }>> & {
+        }, Readonly<import('element-plus').PopoverProps> & Readonly<{
             "onUpdate:visible"?: ((value: boolean) => any) | undefined;
-            "onAfter-enter"?: (() => any) | undefined;
-            "onAfter-leave"?: (() => any) | undefined;
             "onBefore-enter"?: (() => any) | undefined;
             "onBefore-leave"?: (() => any) | undefined;
-        }, {
+            "onAfter-enter"?: (() => any) | undefined;
+            "onAfter-leave"?: (() => any) | undefined;
+        }>, {
             popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
             hide: () => void;
         }, {}, {}, {}, {
-            readonly disabled: boolean;
-            readonly tabindex: string | number;
-            readonly width: string | number;
-            readonly content: string;
-            readonly offset: number;
-            readonly visible: boolean | null;
-            readonly placement: any;
-            readonly effect: import('element-plus').PopperEffect;
-            readonly showAfter: number;
-            readonly hideAfter: number;
-            readonly autoClose: number;
-            readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
-            readonly popperOptions: Partial<Options>;
-            readonly enterable: boolean;
-            readonly triggerKeys: string[];
-            readonly teleported: boolean;
-            readonly persistent: boolean;
-            readonly showArrow: boolean;
+            effect: import('element-plus').PopperEffect;
+            placement: Placement;
+            popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            teleported: boolean;
+            persistent: boolean;
+            visible: boolean | null;
+            enterable: boolean;
+            offset: number;
+            popperOptions: Partial<Options>;
+            showArrow: boolean;
+            content: string;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            triggerKeys: string[];
+            width: string | number;
+            tabindex: string | number;
         }>;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
-        readonly 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";
-        };
-        readonly triggerKeys: {
-            readonly type: import('vue').PropType<string[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => string[];
-        };
-        readonly placement: {
-            readonly type: import('vue').PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: "bottom";
-        };
-        readonly disabled: BooleanConstructor;
-        readonly visible: {
-            readonly type: import('vue').PropType<boolean | null>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: null;
-        };
-        readonly transition: StringConstructor;
-        readonly popperOptions: {
-            readonly type: import('vue').PropType<any>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: () => {};
-        };
-        readonly tabindex: {
-            readonly type: import('vue').PropType<string | number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: 0;
-        };
-        readonly content: {
-            readonly type: import('vue').PropType<string>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: "";
-        };
-        readonly popperStyle: {
-            readonly type: import('vue').PropType<import('vue').StyleValue>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        readonly popperClass: {
-            readonly type: import('vue').PropType<string | {
+    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').PopoverProps> & Readonly<{
+        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+        "onBefore-enter"?: (() => any) | undefined;
+        "onBefore-leave"?: (() => any) | undefined;
+        "onAfter-enter"?: (() => any) | undefined;
+        "onAfter-leave"?: (() => any) | undefined;
+    }>, {
+        popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
+        hide: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:visible": (value: boolean) => void;
+        "before-enter": () => void;
+        "before-leave": () => void;
+        "after-enter": () => void;
+        "after-leave": () => void;
+    }, string, {
+        effect: import('element-plus').PopperEffect;
+        placement: Placement;
+        popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+        teleported: boolean;
+        persistent: boolean;
+        visible: boolean | null;
+        enterable: boolean;
+        offset: number;
+        popperOptions: Partial<Options>;
+        showArrow: boolean;
+        content: string;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+        triggerKeys: string[];
+        width: string | number;
+        tabindex: string | number;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            reference?: (props: {}) => any;
+        } & {
+            default?: (props: {
+                hide: () => void;
+            }) => any;
+        };
+    }) & import('vue').ObjectPlugin & {
+        setPropsDefaults: (defaults: Partial<{
+            readonly trigger?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType> | undefined;
+            readonly triggerKeys?: string[] | undefined;
+            readonly placement?: Placement$1;
+            readonly disabled?: boolean | undefined;
+            readonly visible?: boolean | null | undefined;
+            readonly transition?: string | undefined;
+            readonly popperOptions?: Partial<Options>;
+            readonly tabindex?: string | number | undefined;
+            readonly content?: string | undefined;
+            readonly popperStyle?: import('vue').StyleValue;
+            readonly popperClass?: (string | {
                 [x: string]: boolean;
             } | (string | {
                 [x: string]: boolean;
@@ -969,864 +302,196 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
                 [x: string]: boolean;
             } | (string | {
                 [x: string]: boolean;
-            } | (string | any[] | {
+            } | (string | {
                 [x: string]: boolean;
-            })[])[])[])[])[])[])[])[])[])[]>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        readonly enterable: {
-            readonly default: true;
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            readonly __epPropKey: true;
-        };
-        readonly effect: {
-            readonly default: "light";
-            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            readonly __epPropKey: true;
-        };
-        readonly teleported: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        readonly appendTo: {
-            readonly type: import('vue').PropType<string | HTMLElement>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        readonly title: StringConstructor;
-        readonly width: {
-            readonly type: import('vue').PropType<string | number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: 150;
-        };
-        readonly offset: {
-            readonly type: import('vue').PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly showAfter: {
-            readonly type: import('vue').PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: 0;
-        };
-        readonly hideAfter: {
-            readonly type: import('vue').PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: 200;
-        };
-        readonly autoClose: {
-            readonly type: import('vue').PropType<number>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: 0;
-        };
-        readonly showArrow: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        readonly persistent: {
-            readonly type: import('vue').PropType<boolean>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: true;
-        };
-        readonly "onUpdate:visible": {
-            readonly type: import('vue').PropType<(visible: boolean) => void>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-    }>> & {
-        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
-        "onAfter-enter"?: (() => any) | undefined;
-        "onAfter-leave"?: (() => any) | undefined;
-        "onBefore-enter"?: (() => any) | undefined;
-        "onBefore-leave"?: (() => any) | undefined;
-    }, {
-        popperRef: import('vue').ComputedRef<import('element-plus').PopperInstance | undefined>;
-        hide: () => void;
-    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        "after-enter": () => void;
-        "after-leave": () => void;
-        "before-enter": () => void;
-        "before-leave": () => void;
-        "update:visible": (value: boolean) => void;
-    }, string, {
-        readonly disabled: boolean;
-        readonly tabindex: string | number;
-        readonly width: string | number;
-        readonly content: string;
-        readonly offset: number;
-        readonly visible: boolean | null;
-        readonly placement: any;
-        readonly effect: import('element-plus').PopperEffect;
-        readonly showAfter: number;
-        readonly hideAfter: number;
-        readonly autoClose: number;
-        readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
-        readonly popperOptions: Partial<Options>;
-        readonly enterable: boolean;
-        readonly triggerKeys: string[];
-        readonly teleported: boolean;
-        readonly persistent: boolean;
-        readonly showArrow: boolean;
-    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
-        $slots: {
-            reference?(_: {}): any;
-            default?(_: {}): any;
-        };
-    }) & import('vue').Plugin) & {
-        directive: typeof import('element-plus').ElPopoverDirective;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | undefined;
+            readonly enterable?: boolean | undefined;
+            readonly effect?: import('element-plus').PopperEffect | undefined;
+            readonly teleported?: boolean | undefined;
+            readonly appendTo?: string | HTMLElement | undefined;
+            readonly title?: string | undefined;
+            readonly width?: string | number | undefined;
+            readonly offset?: number | undefined;
+            readonly showAfter?: number | undefined;
+            readonly hideAfter?: number | undefined;
+            readonly autoClose?: number | undefined;
+            readonly showArrow?: boolean | undefined;
+            readonly persistent?: boolean | undefined;
+            readonly "onUpdate:visible"?: (((visible: boolean) => void) & ((value: boolean) => any)) | undefined;
+            readonly "onBefore-enter"?: (() => any) | undefined | undefined;
+            readonly "onBefore-leave"?: (() => any) | undefined | undefined;
+            readonly "onAfter-enter"?: (() => any) | undefined | undefined;
+            readonly "onAfter-leave"?: (() => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps>) => void;
+    } & {
+        directive: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').ObjectDirective<any, any, string, any>>;
     };
-    ElInput: {
-        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
-            readonly inputmode: {
-                readonly type: import('vue').PropType<"text" | "search" | "email" | "decimal" | "none" | "tel" | "url" | "numeric" | undefined>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly name: StringConstructor;
-            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<"" | "default" | "small" | "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 modelModifiers: {
-                readonly type: import('vue').PropType<import('element-plus').InputModelModifiers>;
-                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<"none" | "both" | "horizontal" | "vertical">;
-                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<AutoFill>;
-                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 clearIcon: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly showPassword: BooleanConstructor;
-            readonly showWordLimit: BooleanConstructor;
-            readonly wordLimitPosition: {
-                readonly type: import('vue').PropType<"inside" | "outside">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "inside";
-            };
-            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;
+    ElInput: import('element-plus/es/utils/index.mjs').SFCWithInstall<{
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').InputProps> & Readonly<{
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, evt?: Event | undefined) => 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>;
+            onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        }>, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, 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>;
+            autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+            isComposing: import('vue').Ref<boolean, boolean>;
             focus: () => void | undefined;
             blur: () => void | undefined;
             select: () => void;
-            clear: () => void;
+            clear: (evt?: MouseEvent) => void;
             resizeTextarea: () => void;
-        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            input: (value: string) => void;
-            focus: (evt: FocusEvent) => void;
-            "update:modelValue": (value: string) => void;
-            change: (value: string) => void;
-            clear: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             blur: (evt: FocusEvent) => void;
+            change: (value: string, evt?: Event | undefined) => void;
             compositionend: (evt: CompositionEvent) => void;
             compositionstart: (evt: CompositionEvent) => void;
             compositionupdate: (evt: CompositionEvent) => void;
+            focus: (evt: FocusEvent) => void;
+            input: (value: string) => 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 tabindex: string | number;
-            readonly id: string;
-            readonly type: string;
-            readonly modelValue: string | number | null | undefined;
-            readonly readonly: boolean;
-            readonly modelModifiers: import('element-plus').InputModelModifiers;
-            readonly autosize: import('element-plus').InputAutoSize;
-            readonly autocomplete: AutoFill;
-            readonly wordLimitPosition: "inside" | "outside";
-            readonly containerRole: string;
-            readonly validateEvent: boolean;
-            readonly inputStyle: import('vue').StyleValue;
-            readonly rows: number;
-            readonly inputmode: "text" | "search" | "email" | "decimal" | "none" | "tel" | "url" | "numeric" | undefined;
-            readonly clearable: boolean;
-            readonly showPassword: boolean;
-            readonly showWordLimit: boolean;
-            readonly autofocus: boolean;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            clear: (evt: MouseEvent | undefined) => void;
+            "update:modelValue": (value: string) => void;
+        }, import('vue').PublicProps, {
+            type: import('element-plus').InputType;
+            disabled: boolean;
+            clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            validateEvent: boolean;
+            modelValue: string | number | null;
+            modelModifiers: import('element-plus').InputModelModifiers;
+            autocomplete: string;
+            wordLimitPosition: "inside" | "outside";
+            tabindex: string | number;
+            inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            rows: number;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
             C: {};
             M: {};
             Defaults: {};
-        }, Readonly<import('vue').ExtractPropTypes<{
-            readonly inputmode: {
-                readonly type: import('vue').PropType<"text" | "search" | "email" | "decimal" | "none" | "tel" | "url" | "numeric" | undefined>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly name: StringConstructor;
-            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<"" | "default" | "small" | "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 modelModifiers: {
-                readonly type: import('vue').PropType<import('element-plus').InputModelModifiers>;
-                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<"none" | "both" | "horizontal" | "vertical">;
-                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<AutoFill>;
-                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 clearIcon: {
-                readonly type: import('vue').PropType<string | import('vue').Component>;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            };
-            readonly showPassword: BooleanConstructor;
-            readonly showWordLimit: BooleanConstructor;
-            readonly wordLimitPosition: {
-                readonly type: import('vue').PropType<"inside" | "outside">;
-                readonly required: false;
-                readonly validator: ((val: unknown) => boolean) | undefined;
-                __epPropKey: true;
-            } & {
-                readonly default: "inside";
-            };
-            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;
+        }, Readonly<import('element-plus').InputProps> & Readonly<{
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, evt?: Event | undefined) => 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>;
+            onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        }>, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, 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>;
+            autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+            isComposing: import('vue').Ref<boolean, boolean>;
             focus: () => void | undefined;
             blur: () => void | undefined;
             select: () => void;
-            clear: () => void;
+            clear: (evt?: MouseEvent) => void;
             resizeTextarea: () => void;
         }, {}, {}, {}, {
-            readonly disabled: boolean;
-            readonly tabindex: string | number;
-            readonly id: string;
-            readonly type: string;
-            readonly modelValue: string | number | null | undefined;
-            readonly readonly: boolean;
-            readonly modelModifiers: import('element-plus').InputModelModifiers;
-            readonly autosize: import('element-plus').InputAutoSize;
-            readonly autocomplete: AutoFill;
-            readonly wordLimitPosition: "inside" | "outside";
-            readonly containerRole: string;
-            readonly validateEvent: boolean;
-            readonly inputStyle: import('vue').StyleValue;
-            readonly rows: number;
-            readonly inputmode: "text" | "search" | "email" | "decimal" | "none" | "tel" | "url" | "numeric" | undefined;
-            readonly clearable: boolean;
-            readonly showPassword: boolean;
-            readonly showWordLimit: boolean;
-            readonly autofocus: boolean;
+            type: import('element-plus').InputType;
+            disabled: boolean;
+            clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            validateEvent: boolean;
+            modelValue: string | number | null;
+            modelModifiers: import('element-plus').InputModelModifiers;
+            autocomplete: string;
+            wordLimitPosition: "inside" | "outside";
+            tabindex: string | number;
+            inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            rows: number;
         }>;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
-        readonly inputmode: {
-            readonly type: import('vue').PropType<"text" | "search" | "email" | "decimal" | "none" | "tel" | "url" | "numeric" | undefined>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly name: StringConstructor;
-        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<"" | "default" | "small" | "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 modelModifiers: {
-            readonly type: import('vue').PropType<import('element-plus').InputModelModifiers>;
-            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<"none" | "both" | "horizontal" | "vertical">;
-            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<AutoFill>;
-            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 clearIcon: {
-            readonly type: import('vue').PropType<string | import('vue').Component>;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        };
-        readonly showPassword: BooleanConstructor;
-        readonly showWordLimit: BooleanConstructor;
-        readonly wordLimitPosition: {
-            readonly type: import('vue').PropType<"inside" | "outside">;
-            readonly required: false;
-            readonly validator: ((val: unknown) => boolean) | undefined;
-            __epPropKey: true;
-        } & {
-            readonly default: "inside";
-        };
-        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;
+    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onChange?: ((value: string, evt?: Event | undefined) => 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>;
+        onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }>, {
+        input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, 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>;
+        autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+        isComposing: import('vue').Ref<boolean, boolean>;
         focus: () => void | undefined;
         blur: () => void | undefined;
         select: () => void;
-        clear: () => void;
+        clear: (evt?: MouseEvent) => void;
         resizeTextarea: () => void;
-    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        input: (value: string) => void;
-        focus: (evt: FocusEvent) => void;
-        "update:modelValue": (value: string) => void;
-        change: (value: string) => void;
-        clear: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         blur: (evt: FocusEvent) => void;
+        change: (value: string, evt?: Event | undefined) => void;
         compositionend: (evt: CompositionEvent) => void;
         compositionstart: (evt: CompositionEvent) => void;
         compositionupdate: (evt: CompositionEvent) => void;
+        focus: (evt: FocusEvent) => void;
+        input: (value: string) => void;
         keydown: (evt: Event | KeyboardEvent) => void;
         mouseenter: (evt: MouseEvent) => void;
         mouseleave: (evt: MouseEvent) => void;
+        clear: (evt: MouseEvent | undefined) => void;
+        "update:modelValue": (value: string) => void;
     }, string, {
-        readonly disabled: boolean;
-        readonly tabindex: string | number;
-        readonly id: string;
-        readonly type: string;
-        readonly modelValue: string | number | null | undefined;
-        readonly readonly: boolean;
-        readonly modelModifiers: import('element-plus').InputModelModifiers;
-        readonly autosize: import('element-plus').InputAutoSize;
-        readonly autocomplete: AutoFill;
-        readonly wordLimitPosition: "inside" | "outside";
-        readonly containerRole: string;
-        readonly validateEvent: boolean;
-        readonly inputStyle: import('vue').StyleValue;
-        readonly rows: number;
-        readonly inputmode: "text" | "search" | "email" | "decimal" | "none" | "tel" | "url" | "numeric" | undefined;
-        readonly clearable: boolean;
-        readonly showPassword: boolean;
-        readonly showWordLimit: boolean;
-        readonly autofocus: boolean;
+        type: import('element-plus').InputType;
+        disabled: boolean;
+        clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+        validateEvent: boolean;
+        modelValue: string | number | null;
+        modelModifiers: import('element-plus').InputModelModifiers;
+        autocomplete: string;
+        wordLimitPosition: "inside" | "outside";
+        tabindex: string | number;
+        inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+        rows: number;
     }, {}, 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;
+            prepend?: (props: {}) => any;
+        } & {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            'password-icon'?: (props: {
+                visible: boolean;
+            }) => any;
+        } & {
+            append?: (props: {}) => any;
         };
-    }) & import('vue').Plugin;
+    })>;
     CommandButton: typeof CommandButton;
 }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;