@sdata/web-vue 1.1.0 → 1.3.0

package/es/typography/edit-content.vue.d.ts

@@ -0,0 +1,2344 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    classNames: string[];
+    inputRef: import("vue").Ref<({
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            inputAttrs: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            'update:modelValue': (value: string) => true;
+            input: (value: string, ev: Event) => true;
+            change: (value: string, ev: Event) => true;
+            pressEnter: (ev: KeyboardEvent) => true;
+            clear: (ev: MouseEvent) => true;
+            focus: (ev: FocusEvent) => true;
+            blur: (ev: FocusEvent) => true;
+        }, import("vue").PublicProps, {
+            error: boolean;
+            readonly: boolean;
+            type: "text" | "password";
+            disabled: boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            inputAttrs: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, {
+            error: boolean;
+            readonly: boolean;
+            type: "text" | "password";
+            disabled: boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        size: {
+            type: import("vue").PropType<import("..").Size>;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        placeholder: StringConstructor;
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wordLength: {
+            type: import("vue").PropType<(value: string) => number>;
+        };
+        wordSlice: {
+            type: import("vue").PropType<(value: string, maxLength: number) => string>;
+        };
+        inputAttrs: {
+            type: ObjectConstructor;
+        };
+        type: {
+            type: import("vue").PropType<"text" | "password">;
+            default: string;
+        };
+        prepend: StringConstructor;
+        append: StringConstructor;
+    }>> & Readonly<{
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onChange?: ((value: string, ev: Event) => any) | undefined;
+        onInput?: ((value: string, ev: Event) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        render: () => import("vue/jsx-runtime").JSX.Element;
+    }, {}, {}, {
+        focus(): void;
+        blur(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': (value: string) => true;
+        input: (value: string, ev: Event) => true;
+        change: (value: string, ev: Event) => true;
+        pressEnter: (ev: KeyboardEvent) => true;
+        clear: (ev: MouseEvent) => true;
+        focus: (ev: FocusEvent) => true;
+        blur: (ev: FocusEvent) => true;
+    }, string, {
+        error: boolean;
+        readonly: boolean;
+        type: "text" | "password";
+        disabled: boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        Search: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            searchButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            buttonText: {
+                type: StringConstructor;
+            };
+            buttonProps: {
+                type: import("vue").PropType<import("..").ButtonProps>;
+            };
+        }>, {
+            inputRef: import("vue").Ref<any, any>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            search: (value: string, ev: MouseEvent) => true;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            searchButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            buttonText: {
+                type: StringConstructor;
+            };
+            buttonProps: {
+                type: import("vue").PropType<import("..").ButtonProps>;
+            };
+        }>> & Readonly<{
+            onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
+        }>, {
+            disabled: boolean;
+            loading: boolean;
+            searchButton: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        Password: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            visibility: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultVisibility: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            invisibleButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            inputRef: import("vue").Ref<any, any>;
+            mergedVisible: import("vue").ComputedRef<boolean>;
+            handleInvisible: () => void;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("visibility-change" | "update:visibility")[], "visibility-change" | "update:visibility", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            visibility: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultVisibility: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            invisibleButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onVisibility-change"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visibility"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            visibility: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+        }, {}, {
+            IconEye: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (ev: MouseEvent) => true;
+                }, import("vue").PublicProps, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                strokeWidth: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                strokeLinecap: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                strokeLinejoin: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((ev: MouseEvent) => any) | undefined;
+            }>, {
+                cls: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                onClick: (ev: MouseEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (ev: MouseEvent) => true;
+            }, string, {
+                spin: boolean;
+                strokeWidth: number;
+                strokeLinecap: string;
+                strokeLinejoin: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install: (app: import("vue").App, options?: import("../_utils/types").SDIconOptions) => void;
+            };
+            IconEyeInvisible: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (ev: MouseEvent) => true;
+                }, import("vue").PublicProps, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                strokeWidth: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                strokeLinecap: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                strokeLinejoin: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((ev: MouseEvent) => any) | undefined;
+            }>, {
+                cls: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                onClick: (ev: MouseEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (ev: MouseEvent) => true;
+            }, string, {
+                spin: boolean;
+                strokeWidth: number;
+                strokeLinecap: string;
+                strokeLinejoin: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install: (app: import("vue").App, options?: import("../_utils/types").SDIconOptions) => void;
+            };
+            AIconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefix: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                prefixCls: string;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefix: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                size: "mini" | "small" | "medium" | "large";
+                disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            AInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                inputAttrs: {
+                    type: ObjectConstructor;
+                };
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                render: () => import("vue/jsx-runtime").JSX.Element;
+            }, {}, {}, {
+                focus(): void;
+                blur(): void;
+            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                'update:modelValue': (value: string) => true;
+                input: (value: string, ev: Event) => true;
+                change: (value: string, ev: Event) => true;
+                pressEnter: (ev: KeyboardEvent) => true;
+                clear: (ev: MouseEvent) => true;
+                focus: (ev: FocusEvent) => true;
+                blur: (ev: FocusEvent) => true;
+            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                inputAttrs: {
+                    type: ObjectConstructor;
+                };
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, {
+                error: boolean;
+                readonly: boolean;
+                type: "text" | "password";
+                disabled: boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        Group: import("vue").DefineComponent<{}, {
+            prefixCls: string;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+    }) | undefined, ({
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            inputAttrs: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            'update:modelValue': (value: string) => true;
+            input: (value: string, ev: Event) => true;
+            change: (value: string, ev: Event) => true;
+            pressEnter: (ev: KeyboardEvent) => true;
+            clear: (ev: MouseEvent) => true;
+            focus: (ev: FocusEvent) => true;
+            blur: (ev: FocusEvent) => true;
+        }, import("vue").PublicProps, {
+            error: boolean;
+            readonly: boolean;
+            type: "text" | "password";
+            disabled: boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            inputAttrs: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, {
+            error: boolean;
+            readonly: boolean;
+            type: "text" | "password";
+            disabled: boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        size: {
+            type: import("vue").PropType<import("..").Size>;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        placeholder: StringConstructor;
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wordLength: {
+            type: import("vue").PropType<(value: string) => number>;
+        };
+        wordSlice: {
+            type: import("vue").PropType<(value: string, maxLength: number) => string>;
+        };
+        inputAttrs: {
+            type: ObjectConstructor;
+        };
+        type: {
+            type: import("vue").PropType<"text" | "password">;
+            default: string;
+        };
+        prepend: StringConstructor;
+        append: StringConstructor;
+    }>> & Readonly<{
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onChange?: ((value: string, ev: Event) => any) | undefined;
+        onInput?: ((value: string, ev: Event) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        render: () => import("vue/jsx-runtime").JSX.Element;
+    }, {}, {}, {
+        focus(): void;
+        blur(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': (value: string) => true;
+        input: (value: string, ev: Event) => true;
+        change: (value: string, ev: Event) => true;
+        pressEnter: (ev: KeyboardEvent) => true;
+        clear: (ev: MouseEvent) => true;
+        focus: (ev: FocusEvent) => true;
+        blur: (ev: FocusEvent) => true;
+    }, string, {
+        error: boolean;
+        readonly: boolean;
+        type: "text" | "password";
+        disabled: boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        Search: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            searchButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            buttonText: {
+                type: StringConstructor;
+            };
+            buttonProps: {
+                type: import("vue").PropType<import("..").ButtonProps>;
+            };
+        }>, {
+            inputRef: import("vue").Ref<any, any>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            search: (value: string, ev: MouseEvent) => true;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            searchButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            buttonText: {
+                type: StringConstructor;
+            };
+            buttonProps: {
+                type: import("vue").PropType<import("..").ButtonProps>;
+            };
+        }>> & Readonly<{
+            onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
+        }>, {
+            disabled: boolean;
+            loading: boolean;
+            searchButton: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        Password: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            visibility: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultVisibility: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            invisibleButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            inputRef: import("vue").Ref<any, any>;
+            mergedVisible: import("vue").ComputedRef<boolean>;
+            handleInvisible: () => void;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("visibility-change" | "update:visibility")[], "visibility-change" | "update:visibility", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            visibility: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultVisibility: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            invisibleButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onVisibility-change"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visibility"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            visibility: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+        }, {}, {
+            IconEye: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (ev: MouseEvent) => true;
+                }, import("vue").PublicProps, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                strokeWidth: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                strokeLinecap: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                strokeLinejoin: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((ev: MouseEvent) => any) | undefined;
+            }>, {
+                cls: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                onClick: (ev: MouseEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (ev: MouseEvent) => true;
+            }, string, {
+                spin: boolean;
+                strokeWidth: number;
+                strokeLinecap: string;
+                strokeLinejoin: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install: (app: import("vue").App, options?: import("../_utils/types").SDIconOptions) => void;
+            };
+            IconEyeInvisible: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (ev: MouseEvent) => true;
+                }, import("vue").PublicProps, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                strokeWidth: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                strokeLinecap: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                strokeLinejoin: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((ev: MouseEvent) => any) | undefined;
+            }>, {
+                cls: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                onClick: (ev: MouseEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (ev: MouseEvent) => true;
+            }, string, {
+                spin: boolean;
+                strokeWidth: number;
+                strokeLinecap: string;
+                strokeLinejoin: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install: (app: import("vue").App, options?: import("../_utils/types").SDIconOptions) => void;
+            };
+            AIconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefix: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                prefixCls: string;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefix: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                size: "mini" | "small" | "medium" | "large";
+                disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            AInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                inputAttrs: {
+                    type: ObjectConstructor;
+                };
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                render: () => import("vue/jsx-runtime").JSX.Element;
+            }, {}, {}, {
+                focus(): void;
+                blur(): void;
+            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                'update:modelValue': (value: string) => true;
+                input: (value: string, ev: Event) => true;
+                change: (value: string, ev: Event) => true;
+                pressEnter: (ev: KeyboardEvent) => true;
+                clear: (ev: MouseEvent) => true;
+                focus: (ev: FocusEvent) => true;
+                blur: (ev: FocusEvent) => true;
+            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                inputAttrs: {
+                    type: ObjectConstructor;
+                };
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, {
+                error: boolean;
+                readonly: boolean;
+                type: "text" | "password";
+                disabled: boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        Group: import("vue").DefineComponent<{}, {
+            prefixCls: string;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+    }) | undefined>;
+    onBlur: () => void;
+    onChange: (value: string) => void;
+    onEnd: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "end" | "update:text")[], "change" | "end" | "update:text", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    onEnd?: ((...args: any[]) => any) | undefined;
+    "onUpdate:text"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {
+    Input: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            inputAttrs: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            'update:modelValue': (value: string) => true;
+            input: (value: string, ev: Event) => true;
+            change: (value: string, ev: Event) => true;
+            pressEnter: (ev: KeyboardEvent) => true;
+            clear: (ev: MouseEvent) => true;
+            focus: (ev: FocusEvent) => true;
+            blur: (ev: FocusEvent) => true;
+        }, import("vue").PublicProps, {
+            error: boolean;
+            readonly: boolean;
+            type: "text" | "password";
+            disabled: boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            inputAttrs: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onFocus?: ((ev: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, ev: Event) => any) | undefined;
+            onInput?: ((value: string, ev: Event) => any) | undefined;
+            onBlur?: ((ev: FocusEvent) => any) | undefined;
+            onClear?: ((ev: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, {
+            error: boolean;
+            readonly: boolean;
+            type: "text" | "password";
+            disabled: boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        size: {
+            type: import("vue").PropType<import("..").Size>;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        placeholder: StringConstructor;
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wordLength: {
+            type: import("vue").PropType<(value: string) => number>;
+        };
+        wordSlice: {
+            type: import("vue").PropType<(value: string, maxLength: number) => string>;
+        };
+        inputAttrs: {
+            type: ObjectConstructor;
+        };
+        type: {
+            type: import("vue").PropType<"text" | "password">;
+            default: string;
+        };
+        prepend: StringConstructor;
+        append: StringConstructor;
+    }>> & Readonly<{
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onChange?: ((value: string, ev: Event) => any) | undefined;
+        onInput?: ((value: string, ev: Event) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        onClear?: ((ev: MouseEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+    }>, {
+        inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        render: () => import("vue/jsx-runtime").JSX.Element;
+    }, {}, {}, {
+        focus(): void;
+        blur(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': (value: string) => true;
+        input: (value: string, ev: Event) => true;
+        change: (value: string, ev: Event) => true;
+        pressEnter: (ev: KeyboardEvent) => true;
+        clear: (ev: MouseEvent) => true;
+        focus: (ev: FocusEvent) => true;
+        blur: (ev: FocusEvent) => true;
+    }, string, {
+        error: boolean;
+        readonly: boolean;
+        type: "text" | "password";
+        disabled: boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        Search: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            searchButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            buttonText: {
+                type: StringConstructor;
+            };
+            buttonProps: {
+                type: import("vue").PropType<import("..").ButtonProps>;
+            };
+        }>, {
+            inputRef: import("vue").Ref<any, any>;
+            render: () => import("vue/jsx-runtime").JSX.Element;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            search: (value: string, ev: MouseEvent) => true;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            searchButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: import("vue").PropType<import("..").Size>;
+            };
+            buttonText: {
+                type: StringConstructor;
+            };
+            buttonProps: {
+                type: import("vue").PropType<import("..").ButtonProps>;
+            };
+        }>> & Readonly<{
+            onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
+        }>, {
+            disabled: boolean;
+            loading: boolean;
+            searchButton: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        Password: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            visibility: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultVisibility: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            invisibleButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            inputRef: import("vue").Ref<any, any>;
+            mergedVisible: import("vue").ComputedRef<boolean>;
+            handleInvisible: () => void;
+        }, {}, {}, {
+            focus(): void;
+            blur(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("visibility-change" | "update:visibility")[], "visibility-change" | "update:visibility", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            visibility: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultVisibility: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            invisibleButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onVisibility-change"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visibility"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            visibility: boolean;
+            defaultVisibility: boolean;
+            invisibleButton: boolean;
+        }, {}, {
+            IconEye: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (ev: MouseEvent) => true;
+                }, import("vue").PublicProps, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                strokeWidth: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                strokeLinecap: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                strokeLinejoin: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((ev: MouseEvent) => any) | undefined;
+            }>, {
+                cls: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                onClick: (ev: MouseEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (ev: MouseEvent) => true;
+            }, string, {
+                spin: boolean;
+                strokeWidth: number;
+                strokeLinecap: string;
+                strokeLinejoin: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install: (app: import("vue").App, options?: import("../_utils/types").SDIconOptions) => void;
+            };
+            IconEyeInvisible: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (ev: MouseEvent) => true;
+                }, import("vue").PublicProps, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    size: {
+                        type: (StringConstructor | NumberConstructor)[];
+                    };
+                    strokeWidth: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    strokeLinecap: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    strokeLinejoin: {
+                        type: StringConstructor;
+                        default: string;
+                        validator: (value: any) => boolean;
+                    };
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                }>> & Readonly<{
+                    onClick?: ((ev: MouseEvent) => any) | undefined;
+                }>, {
+                    cls: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean;
+                    })[]>;
+                    innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    onClick: (ev: MouseEvent) => void;
+                }, {}, {}, {}, {
+                    spin: boolean;
+                    strokeWidth: number;
+                    strokeLinecap: string;
+                    strokeLinejoin: string;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                strokeWidth: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                strokeLinecap: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                strokeLinejoin: {
+                    type: StringConstructor;
+                    default: string;
+                    validator: (value: any) => boolean;
+                };
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+            }>> & Readonly<{
+                onClick?: ((ev: MouseEvent) => any) | undefined;
+            }>, {
+                cls: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                onClick: (ev: MouseEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (ev: MouseEvent) => true;
+            }, string, {
+                spin: boolean;
+                strokeWidth: number;
+                strokeLinecap: string;
+                strokeLinejoin: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install: (app: import("vue").App, options?: import("../_utils/types").SDIconOptions) => void;
+            };
+            AIconHover: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefix: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                prefixCls: string;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefix: {
+                    type: StringConstructor;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                size: "mini" | "small" | "medium" | "large";
+                disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            AInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                inputAttrs: {
+                    type: ObjectConstructor;
+                };
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                render: () => import("vue/jsx-runtime").JSX.Element;
+            }, {}, {}, {
+                focus(): void;
+                blur(): void;
+            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                'update:modelValue': (value: string) => true;
+                input: (value: string, ev: Event) => true;
+                change: (value: string, ev: Event) => true;
+                pressEnter: (ev: KeyboardEvent) => true;
+                clear: (ev: MouseEvent) => true;
+                focus: (ev: FocusEvent) => true;
+                blur: (ev: FocusEvent) => true;
+            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: {
+                    type: import("vue").PropType<import("..").Size>;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                inputAttrs: {
+                    type: ObjectConstructor;
+                };
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onFocus?: ((ev: FocusEvent) => any) | undefined;
+                onChange?: ((value: string, ev: Event) => any) | undefined;
+                onInput?: ((value: string, ev: Event) => any) | undefined;
+                onBlur?: ((ev: FocusEvent) => any) | undefined;
+                onClear?: ((ev: MouseEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onPressEnter?: ((ev: KeyboardEvent) => any) | undefined;
+            }>, {
+                error: boolean;
+                readonly: boolean;
+                type: "text" | "password";
+                disabled: boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        Group: import("vue").DefineComponent<{}, {
+            prefixCls: string;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+    };
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;