@sdata/web-vue 3.30.0 → 4.0.0

package/es/mention/index.d.ts

@@ -1,6 +1,6 @@
 import type { App } from 'vue';
 import type { SDOptions } from '../_utils/types';
-import _Mention from './mention';
+import _Mention from './mention.vue';
 declare const Mention: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
         modelValue: StringConstructor;
@@ -9,7 +9,7 @@ declare const Mention: {
             default: string;
         };
         data: {
-            type: import("vue").PropType<(string | number | import("..").SelectOptionData | import("..").SelectOptionGroup)[]>;
+            type: import("vue").PropType<(string | number | import("../index.ts").SelectOptionData | import("../index.ts").SelectOptionGroup)[]>;
             default: () => never[];
         };
         prefix: {
@@ -44,37 +44,1087 @@ declare const Mention: {
             type: BooleanConstructor;
             default: boolean;
         };
-        floatingOptions: {
-            type: import("vue").PropType<import("..").FloatingOptions>;
-        };
+        floatingOptions: import("vue").PropType<import("../index.ts").FloatingOptions>;
     }>> & Readonly<{
         onSearch?: ((_value: string, _prefix: string) => any) | undefined;
-        onClear?: ((_ev: Event) => any) | undefined;
-        onFocus?: ((_ev: FocusEvent) => any) | undefined;
-        onBlur?: ((_ev: FocusEvent) => any) | undefined;
+        onClear?: ((_event: Event) => any) | undefined;
+        onFocus?: ((_event: FocusEvent) => any) | undefined;
+        onBlur?: ((_event: FocusEvent) => any) | undefined;
         onChange?: ((_value: string) => any) | undefined;
         onSelect?: ((_value: string | number | Record<string, any> | undefined) => any) | undefined;
         "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
     }>, {
-        inputRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
-        render: () => import("vue/jsx-runtime").JSX.Element;
-    }, {}, {}, {
-        focus(): void;
-        blur(): void;
-    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        'update:modelValue': (_value: string) => true;
-        change: (_value: string) => true;
-        search: (_value: string, _prefix: string) => true;
-        select: (_value: string | number | Record<string, any> | undefined) => true;
-        clear: (_ev: Event) => true;
-        focus: (_ev: FocusEvent) => true;
-        blur: (_ev: FocusEvent) => true;
+        inputRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }> & Omit<{
+                readonly type: "text" | "password";
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly fitWidthFallback: string;
+                readonly size?: "small" | "medium" | "large" | "mini" | undefined;
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly inputAttrs?: Record<string, any> | undefined;
+                readonly prepend?: string | undefined;
+                readonly append?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly onClear?: ((_event: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_event: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_event: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _event: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _event: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                readonly onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _event: MouseEvent) => void) & ((event: "focus", _event: FocusEvent) => void) & ((event: "blur", _event: FocusEvent) => void) & ((event: "change", _value: string, _event: Event) => void) & ((event: "input", _value: string, _event: Event) => void) & ((event: "update:modelValue", _value: string) => void) & ((event: "pressEnter", _event: KeyboardEvent) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: import("vue").PropType<import("../index.ts").Size>;
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: import("vue").PropType<(value: string) => number>;
+                wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+                inputAttrs: ObjectConstructor;
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                fitWidthFallback: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onClear?: ((_event: MouseEvent) => any) | undefined;
+                onFocus?: ((_event: FocusEvent) => any) | undefined;
+                onBlur?: ((_event: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _event: Event) => any) | undefined;
+                onInput?: ((_value: string, _event: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_event: MouseEvent) => void;
+                focus: (_event: FocusEvent) => void;
+                blur: (_event: FocusEvent) => void;
+                change: (_value: string, _event: Event) => void;
+                input: (_value: string, _event: Event) => void;
+                "update:modelValue": (_value: string) => void;
+                pressEnter: (_event: KeyboardEvent) => void;
+            }, string, {
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: import("vue").PropType<import("../index.ts").Size>;
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: import("vue").PropType<(value: string) => number>;
+            wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+            inputAttrs: ObjectConstructor;
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            fitWidthFallback: {
+                type: StringConstructor;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onClear?: ((_event: MouseEvent) => any) | undefined;
+            onFocus?: ((_event: FocusEvent) => any) | undefined;
+            onBlur?: ((_event: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _event: Event) => any) | undefined;
+            onInput?: ((_value: string, _event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "inputRef" | ("type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback")> & {
+            inputRef: HTMLInputElement | undefined;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                prefix?: (props: {}) => any;
+            } & {
+                suffix?: (props: {}) => any;
+            } & {
+                prepend?: (props: {}) => any;
+            } & {
+                append?: (props: {}) => any;
+            };
+        }) | ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly textareaAttrs?: Record<string, any> | undefined;
+                readonly onClear?: ((_ev: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _ev: MouseEvent) => void) & ((event: "focus", _ev: FocusEvent) => void) & ((event: "blur", _ev: FocusEvent) => void) & ((event: "change", _value: string, _ev: Event) => void) & ((event: "input", _value: string, _ev: Event) => void) & ((event: "update:modelValue", _value: string) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autoSize: {
+                    type: import("vue").PropType<boolean | {
+                        minRows?: number;
+                        maxRows?: number;
+                    }>;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                textareaAttrs: {
+                    type: import("vue").PropType<Record<string, any>>;
+                };
+            }>> & Readonly<{
+                onClear?: ((_ev: MouseEvent) => any) | undefined;
+                onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            }>, {
+                focus: () => void;
+                blur: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_ev: MouseEvent) => any;
+                focus: (_ev: FocusEvent) => any;
+                blur: (_ev: FocusEvent) => any;
+                change: (_value: string, _ev: Event) => any;
+                input: (_value: string, _ev: Event) => any;
+                "update:modelValue": (_value: string) => any;
+            }, string, {
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoSize: {
+                type: import("vue").PropType<boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                }>;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            textareaAttrs: {
+                type: import("vue").PropType<Record<string, any>>;
+            };
+        }>> & Readonly<{
+            onClear?: ((_ev: MouseEvent) => any) | undefined;
+            onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        }>, "focus" | "blur" | ("disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize")> & {
+            focus: () => void;
+            blur: () => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                suffix?: (props: {}) => any;
+            };
+        }) | undefined, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }> & Omit<{
+                readonly type: "text" | "password";
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly fitWidthFallback: string;
+                readonly size?: "small" | "medium" | "large" | "mini" | undefined;
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly inputAttrs?: Record<string, any> | undefined;
+                readonly prepend?: string | undefined;
+                readonly append?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly onClear?: ((_event: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_event: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_event: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _event: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _event: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                readonly onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _event: MouseEvent) => void) & ((event: "focus", _event: FocusEvent) => void) & ((event: "blur", _event: FocusEvent) => void) & ((event: "change", _value: string, _event: Event) => void) & ((event: "input", _value: string, _event: Event) => void) & ((event: "update:modelValue", _value: string) => void) & ((event: "pressEnter", _event: KeyboardEvent) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: import("vue").PropType<import("../index.ts").Size>;
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: import("vue").PropType<(value: string) => number>;
+                wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+                inputAttrs: ObjectConstructor;
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                fitWidthFallback: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onClear?: ((_event: MouseEvent) => any) | undefined;
+                onFocus?: ((_event: FocusEvent) => any) | undefined;
+                onBlur?: ((_event: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _event: Event) => any) | undefined;
+                onInput?: ((_value: string, _event: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_event: MouseEvent) => void;
+                focus: (_event: FocusEvent) => void;
+                blur: (_event: FocusEvent) => void;
+                change: (_value: string, _event: Event) => void;
+                input: (_value: string, _event: Event) => void;
+                "update:modelValue": (_value: string) => void;
+                pressEnter: (_event: KeyboardEvent) => void;
+            }, string, {
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: import("vue").PropType<import("../index.ts").Size>;
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: import("vue").PropType<(value: string) => number>;
+            wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+            inputAttrs: ObjectConstructor;
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            fitWidthFallback: {
+                type: StringConstructor;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onClear?: ((_event: MouseEvent) => any) | undefined;
+            onFocus?: ((_event: FocusEvent) => any) | undefined;
+            onBlur?: ((_event: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _event: Event) => any) | undefined;
+            onInput?: ((_value: string, _event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "inputRef" | ("type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback")> & {
+            inputRef: HTMLInputElement | undefined;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                prefix?: (props: {}) => any;
+            } & {
+                suffix?: (props: {}) => any;
+            } & {
+                prepend?: (props: {}) => any;
+            } & {
+                append?: (props: {}) => any;
+            };
+        }) | ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly textareaAttrs?: Record<string, any> | undefined;
+                readonly onClear?: ((_ev: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _ev: MouseEvent) => void) & ((event: "focus", _ev: FocusEvent) => void) & ((event: "blur", _ev: FocusEvent) => void) & ((event: "change", _value: string, _ev: Event) => void) & ((event: "input", _value: string, _ev: Event) => void) & ((event: "update:modelValue", _value: string) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autoSize: {
+                    type: import("vue").PropType<boolean | {
+                        minRows?: number;
+                        maxRows?: number;
+                    }>;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                textareaAttrs: {
+                    type: import("vue").PropType<Record<string, any>>;
+                };
+            }>> & Readonly<{
+                onClear?: ((_ev: MouseEvent) => any) | undefined;
+                onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            }>, {
+                focus: () => void;
+                blur: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_ev: MouseEvent) => any;
+                focus: (_ev: FocusEvent) => any;
+                blur: (_ev: FocusEvent) => any;
+                change: (_value: string, _ev: Event) => any;
+                input: (_value: string, _ev: Event) => any;
+                "update:modelValue": (_value: string) => any;
+            }, string, {
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoSize: {
+                type: import("vue").PropType<boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                }>;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            textareaAttrs: {
+                type: import("vue").PropType<Record<string, any>>;
+            };
+        }>> & Readonly<{
+            onClear?: ((_ev: MouseEvent) => any) | undefined;
+            onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        }>, "focus" | "blur" | ("disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize")> & {
+            focus: () => void;
+            blur: () => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                suffix?: (props: {}) => any;
+            };
+        }) | undefined>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        search: (_value: string, _prefix: string) => void;
+        clear: (_event: Event) => void;
+        focus: (_event: FocusEvent) => void;
+        blur: (_event: FocusEvent) => void;
+        change: (_value: string) => void;
+        select: (_value: string | number | Record<string, any> | undefined) => void;
+        "update:modelValue": (_value: string) => void;
     }, import("vue").PublicProps, {
         type: "textarea" | "input";
         split: string;
         disabled: boolean;
         readonly: string | boolean;
-        data: (string | number | import("..").SelectOptionData | import("..").SelectOptionGroup)[];
+        data: (string | number | import("../index.ts").SelectOptionData | import("../index.ts").SelectOptionGroup)[];
         prefix: string | string[];
         defaultValue: string;
         allowClear: boolean;
@@ -94,7 +1144,7 @@ declare const Mention: {
             default: string;
         };
         data: {
-            type: import("vue").PropType<(string | number | import("..").SelectOptionData | import("..").SelectOptionGroup)[]>;
+            type: import("vue").PropType<(string | number | import("../index.ts").SelectOptionData | import("../index.ts").SelectOptionGroup)[]>;
             default: () => never[];
         };
         prefix: {
@@ -129,29 +1179,1079 @@ declare const Mention: {
             type: BooleanConstructor;
             default: boolean;
         };
-        floatingOptions: {
-            type: import("vue").PropType<import("..").FloatingOptions>;
-        };
+        floatingOptions: import("vue").PropType<import("../index.ts").FloatingOptions>;
     }>> & Readonly<{
         onSearch?: ((_value: string, _prefix: string) => any) | undefined;
-        onClear?: ((_ev: Event) => any) | undefined;
-        onFocus?: ((_ev: FocusEvent) => any) | undefined;
-        onBlur?: ((_ev: FocusEvent) => any) | undefined;
+        onClear?: ((_event: Event) => any) | undefined;
+        onFocus?: ((_event: FocusEvent) => any) | undefined;
+        onBlur?: ((_event: FocusEvent) => any) | undefined;
         onChange?: ((_value: string) => any) | undefined;
         onSelect?: ((_value: string | number | Record<string, any> | undefined) => any) | undefined;
         "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
     }>, {
-        inputRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
-        render: () => import("vue/jsx-runtime").JSX.Element;
-    }, {}, {}, {
-        focus(): void;
-        blur(): void;
-    }, {
+        inputRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }> & Omit<{
+                readonly type: "text" | "password";
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly fitWidthFallback: string;
+                readonly size?: "small" | "medium" | "large" | "mini" | undefined;
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly inputAttrs?: Record<string, any> | undefined;
+                readonly prepend?: string | undefined;
+                readonly append?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly onClear?: ((_event: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_event: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_event: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _event: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _event: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                readonly onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _event: MouseEvent) => void) & ((event: "focus", _event: FocusEvent) => void) & ((event: "blur", _event: FocusEvent) => void) & ((event: "change", _value: string, _event: Event) => void) & ((event: "input", _value: string, _event: Event) => void) & ((event: "update:modelValue", _value: string) => void) & ((event: "pressEnter", _event: KeyboardEvent) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: import("vue").PropType<import("../index.ts").Size>;
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: import("vue").PropType<(value: string) => number>;
+                wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+                inputAttrs: ObjectConstructor;
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                fitWidthFallback: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onClear?: ((_event: MouseEvent) => any) | undefined;
+                onFocus?: ((_event: FocusEvent) => any) | undefined;
+                onBlur?: ((_event: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _event: Event) => any) | undefined;
+                onInput?: ((_value: string, _event: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_event: MouseEvent) => void;
+                focus: (_event: FocusEvent) => void;
+                blur: (_event: FocusEvent) => void;
+                change: (_value: string, _event: Event) => void;
+                input: (_value: string, _event: Event) => void;
+                "update:modelValue": (_value: string) => void;
+                pressEnter: (_event: KeyboardEvent) => void;
+            }, string, {
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: import("vue").PropType<import("../index.ts").Size>;
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: import("vue").PropType<(value: string) => number>;
+            wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+            inputAttrs: ObjectConstructor;
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            fitWidthFallback: {
+                type: StringConstructor;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onClear?: ((_event: MouseEvent) => any) | undefined;
+            onFocus?: ((_event: FocusEvent) => any) | undefined;
+            onBlur?: ((_event: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _event: Event) => any) | undefined;
+            onInput?: ((_value: string, _event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "inputRef" | ("type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback")> & {
+            inputRef: HTMLInputElement | undefined;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                prefix?: (props: {}) => any;
+            } & {
+                suffix?: (props: {}) => any;
+            } & {
+                prepend?: (props: {}) => any;
+            } & {
+                append?: (props: {}) => any;
+            };
+        }) | ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly textareaAttrs?: Record<string, any> | undefined;
+                readonly onClear?: ((_ev: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _ev: MouseEvent) => void) & ((event: "focus", _ev: FocusEvent) => void) & ((event: "blur", _ev: FocusEvent) => void) & ((event: "change", _value: string, _ev: Event) => void) & ((event: "input", _value: string, _ev: Event) => void) & ((event: "update:modelValue", _value: string) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autoSize: {
+                    type: import("vue").PropType<boolean | {
+                        minRows?: number;
+                        maxRows?: number;
+                    }>;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                textareaAttrs: {
+                    type: import("vue").PropType<Record<string, any>>;
+                };
+            }>> & Readonly<{
+                onClear?: ((_ev: MouseEvent) => any) | undefined;
+                onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            }>, {
+                focus: () => void;
+                blur: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_ev: MouseEvent) => any;
+                focus: (_ev: FocusEvent) => any;
+                blur: (_ev: FocusEvent) => any;
+                change: (_value: string, _ev: Event) => any;
+                input: (_value: string, _ev: Event) => any;
+                "update:modelValue": (_value: string) => any;
+            }, string, {
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoSize: {
+                type: import("vue").PropType<boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                }>;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            textareaAttrs: {
+                type: import("vue").PropType<Record<string, any>>;
+            };
+        }>> & Readonly<{
+            onClear?: ((_ev: MouseEvent) => any) | undefined;
+            onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        }>, "focus" | "blur" | ("disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize")> & {
+            focus: () => void;
+            blur: () => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                suffix?: (props: {}) => any;
+            };
+        }) | undefined, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }> & Omit<{
+                readonly type: "text" | "password";
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly fitWidthFallback: string;
+                readonly size?: "small" | "medium" | "large" | "mini" | undefined;
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly inputAttrs?: Record<string, any> | undefined;
+                readonly prepend?: string | undefined;
+                readonly append?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly onClear?: ((_event: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_event: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_event: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _event: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _event: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                readonly onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _event: MouseEvent) => void) & ((event: "focus", _event: FocusEvent) => void) & ((event: "blur", _event: FocusEvent) => void) & ((event: "change", _value: string, _event: Event) => void) & ((event: "input", _value: string, _event: Event) => void) & ((event: "update:modelValue", _value: string) => void) & ((event: "pressEnter", _event: KeyboardEvent) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                size: import("vue").PropType<import("../index.ts").Size>;
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                wordLength: import("vue").PropType<(value: string) => number>;
+                wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+                inputAttrs: ObjectConstructor;
+                type: {
+                    type: import("vue").PropType<"text" | "password">;
+                    default: string;
+                };
+                fitWidthFallback: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                prepend: StringConstructor;
+                append: StringConstructor;
+            }>> & Readonly<{
+                onClear?: ((_event: MouseEvent) => any) | undefined;
+                onFocus?: ((_event: FocusEvent) => any) | undefined;
+                onBlur?: ((_event: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _event: Event) => any) | undefined;
+                onInput?: ((_value: string, _event: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+                onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+            }>, {
+                inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_event: MouseEvent) => void;
+                focus: (_event: FocusEvent) => void;
+                blur: (_event: FocusEvent) => void;
+                change: (_value: string, _event: Event) => void;
+                input: (_value: string, _event: Event) => void;
+                "update:modelValue": (_value: string) => void;
+                pressEnter: (_event: KeyboardEvent) => void;
+            }, string, {
+                type: "text" | "password";
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                fitWidthFallback: string;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: import("vue").PropType<import("../index.ts").Size>;
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: import("vue").PropType<(value: string) => number>;
+            wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+            inputAttrs: ObjectConstructor;
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            fitWidthFallback: {
+                type: StringConstructor;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onClear?: ((_event: MouseEvent) => any) | undefined;
+            onFocus?: ((_event: FocusEvent) => any) | undefined;
+            onBlur?: ((_event: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _event: Event) => any) | undefined;
+            onInput?: ((_value: string, _event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        }>, "focus" | "blur" | "inputRef" | ("type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback")> & {
+            inputRef: HTMLInputElement | undefined;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                prefix?: (props: {}) => any;
+            } & {
+                suffix?: (props: {}) => any;
+            } & {
+                prepend?: (props: {}) => any;
+            } & {
+                append?: (props: {}) => any;
+            };
+        }) | ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly error: boolean;
+                readonly readonly: string | boolean;
+                readonly defaultValue: string;
+                readonly allowClear: boolean;
+                readonly fitWidth: boolean;
+                readonly maxWFull: boolean;
+                readonly maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                readonly showWordLimit: boolean;
+                readonly autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+                readonly modelValue?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly wordLength?: ((value: string) => number) | undefined;
+                readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+                readonly textareaAttrs?: Record<string, any> | undefined;
+                readonly onClear?: ((_ev: MouseEvent) => any) | undefined;
+                readonly onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                readonly onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", _ev: MouseEvent) => void) & ((event: "focus", _ev: FocusEvent) => void) & ((event: "blur", _ev: FocusEvent) => void) & ((event: "change", _value: string, _ev: Event) => void) & ((event: "input", _value: string, _ev: Event) => void) & ((event: "update:modelValue", _value: string) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                modelValue: StringConstructor;
+                defaultValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                placeholder: StringConstructor;
+                fitWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxWFull: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                readonly: {
+                    type: (StringConstructor | BooleanConstructor)[];
+                    default: boolean;
+                };
+                error: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxLength: {
+                    type: import("vue").PropType<number | {
+                        length: number;
+                        errorOnly?: boolean;
+                    }>;
+                    default: number;
+                };
+                showWordLimit: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                allowClear: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autoSize: {
+                    type: import("vue").PropType<boolean | {
+                        minRows?: number;
+                        maxRows?: number;
+                    }>;
+                    default: boolean;
+                };
+                wordLength: {
+                    type: import("vue").PropType<(value: string) => number>;
+                };
+                wordSlice: {
+                    type: import("vue").PropType<(value: string, maxLength: number) => string>;
+                };
+                textareaAttrs: {
+                    type: import("vue").PropType<Record<string, any>>;
+                };
+            }>> & Readonly<{
+                onClear?: ((_ev: MouseEvent) => any) | undefined;
+                onFocus?: ((_ev: FocusEvent) => any) | undefined;
+                onBlur?: ((_ev: FocusEvent) => any) | undefined;
+                onChange?: ((_value: string, _ev: Event) => any) | undefined;
+                onInput?: ((_value: string, _ev: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            }>, {
+                focus: () => void;
+                blur: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                clear: (_ev: MouseEvent) => any;
+                focus: (_ev: FocusEvent) => any;
+                blur: (_ev: FocusEvent) => any;
+                change: (_value: string, _ev: Event) => any;
+                input: (_value: string, _ev: Event) => any;
+                "update:modelValue": (_value: string) => any;
+            }, string, {
+                disabled: boolean;
+                error: boolean;
+                readonly: string | boolean;
+                defaultValue: string;
+                allowClear: boolean;
+                fitWidth: boolean;
+                maxWFull: boolean;
+                maxLength: number | {
+                    length: number;
+                    errorOnly?: boolean;
+                };
+                showWordLimit: boolean;
+                autoSize: boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                };
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoSize: {
+                type: import("vue").PropType<boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                }>;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            textareaAttrs: {
+                type: import("vue").PropType<Record<string, any>>;
+            };
+        }>> & Readonly<{
+            onClear?: ((_ev: MouseEvent) => any) | undefined;
+            onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        }>, "focus" | "blur" | ("disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize")> & {
+            focus: () => void;
+            blur: () => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                suffix?: (props: {}) => any;
+            };
+        }) | undefined>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+    }, {}, {}, {}, {
         type: "textarea" | "input";
         split: string;
         disabled: boolean;
         readonly: string | boolean;
-        data: (string | number | import("..").SelectOptionData | import("..").SelectOptionGroup)[];
+        data: (string | number | import("../index.ts").SelectOptionData | import("../index.ts").SelectOptionGroup)[];
         prefix: string | string[];
         defaultValue: string;
         allowClear: boolean;
@@ -168,7 +2268,7 @@ declare const Mention: {
         default: string;
     };
     data: {
-        type: import("vue").PropType<(string | number | import("..").SelectOptionData | import("..").SelectOptionGroup)[]>;
+        type: import("vue").PropType<(string | number | import("../index.ts").SelectOptionData | import("../index.ts").SelectOptionGroup)[]>;
         default: () => never[];
     };
     prefix: {
@@ -203,43 +2303,1119 @@ declare const Mention: {
         type: BooleanConstructor;
         default: boolean;
     };
-    floatingOptions: {
-        type: import("vue").PropType<import("..").FloatingOptions>;
-    };
+    floatingOptions: import("vue").PropType<import("../index.ts").FloatingOptions>;
 }>> & Readonly<{
     onSearch?: ((_value: string, _prefix: string) => any) | undefined;
-    onClear?: ((_ev: Event) => any) | undefined;
-    onFocus?: ((_ev: FocusEvent) => any) | undefined;
-    onBlur?: ((_ev: FocusEvent) => any) | undefined;
+    onClear?: ((_event: Event) => any) | undefined;
+    onFocus?: ((_event: FocusEvent) => any) | undefined;
+    onBlur?: ((_event: FocusEvent) => any) | undefined;
     onChange?: ((_value: string) => any) | undefined;
     onSelect?: ((_value: string | number | Record<string, any> | undefined) => any) | undefined;
     "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
 }>, {
-    inputRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
-    render: () => import("vue/jsx-runtime").JSX.Element;
-}, {}, {}, {
-    focus(): void;
-    blur(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    'update:modelValue': (_value: string) => true;
-    change: (_value: string) => true;
-    search: (_value: string, _prefix: string) => true;
-    select: (_value: string | number | Record<string, any> | undefined) => true;
-    clear: (_ev: Event) => true;
-    focus: (_ev: FocusEvent) => true;
-    blur: (_ev: FocusEvent) => true;
+    inputRef: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }> & Omit<{
+            readonly type: "text" | "password";
+            readonly disabled: boolean;
+            readonly error: boolean;
+            readonly readonly: string | boolean;
+            readonly defaultValue: string;
+            readonly allowClear: boolean;
+            readonly fitWidth: boolean;
+            readonly maxWFull: boolean;
+            readonly maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            readonly showWordLimit: boolean;
+            readonly fitWidthFallback: string;
+            readonly size?: "small" | "medium" | "large" | "mini" | undefined;
+            readonly modelValue?: string | undefined;
+            readonly placeholder?: string | undefined;
+            readonly inputAttrs?: Record<string, any> | undefined;
+            readonly prepend?: string | undefined;
+            readonly append?: string | undefined;
+            readonly wordLength?: ((value: string) => number) | undefined;
+            readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+            readonly onClear?: ((_event: MouseEvent) => any) | undefined;
+            readonly onFocus?: ((_event: FocusEvent) => any) | undefined;
+            readonly onBlur?: ((_event: FocusEvent) => any) | undefined;
+            readonly onChange?: ((_value: string, _event: Event) => any) | undefined;
+            readonly onInput?: ((_value: string, _event: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            readonly onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "clear", _event: MouseEvent) => void) & ((event: "focus", _event: FocusEvent) => void) & ((event: "blur", _event: FocusEvent) => void) & ((event: "change", _value: string, _event: Event) => void) & ((event: "input", _value: string, _event: Event) => void) & ((event: "update:modelValue", _value: string) => void) & ((event: "pressEnter", _event: KeyboardEvent) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: import("vue").PropType<import("../index.ts").Size>;
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: import("vue").PropType<(value: string) => number>;
+            wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+            inputAttrs: ObjectConstructor;
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            fitWidthFallback: {
+                type: StringConstructor;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onClear?: ((_event: MouseEvent) => any) | undefined;
+            onFocus?: ((_event: FocusEvent) => any) | undefined;
+            onBlur?: ((_event: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _event: Event) => any) | undefined;
+            onInput?: ((_value: string, _event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            clear: (_event: MouseEvent) => void;
+            focus: (_event: FocusEvent) => void;
+            blur: (_event: FocusEvent) => void;
+            change: (_value: string, _event: Event) => void;
+            input: (_value: string, _event: Event) => void;
+            "update:modelValue": (_value: string) => void;
+            pressEnter: (_event: KeyboardEvent) => void;
+        }, string, {
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        type: "text" | "password";
+        disabled: boolean;
+        error: boolean;
+        readonly: string | boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        fitWidth: boolean;
+        maxWFull: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+        fitWidthFallback: string;
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        size: import("vue").PropType<import("../index.ts").Size>;
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: (StringConstructor | BooleanConstructor)[];
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        placeholder: StringConstructor;
+        fitWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxWFull: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wordLength: import("vue").PropType<(value: string) => number>;
+        wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+        inputAttrs: ObjectConstructor;
+        type: {
+            type: import("vue").PropType<"text" | "password">;
+            default: string;
+        };
+        fitWidthFallback: {
+            type: StringConstructor;
+            default: string;
+        };
+        prepend: StringConstructor;
+        append: StringConstructor;
+    }>> & Readonly<{
+        onClear?: ((_event: MouseEvent) => any) | undefined;
+        onFocus?: ((_event: FocusEvent) => any) | undefined;
+        onBlur?: ((_event: FocusEvent) => any) | undefined;
+        onChange?: ((_value: string, _event: Event) => any) | undefined;
+        onInput?: ((_value: string, _event: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+    }>, "focus" | "blur" | "inputRef" | ("type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback")> & {
+        inputRef: HTMLInputElement | undefined;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            prepend?: (props: {}) => any;
+        } & {
+            append?: (props: {}) => any;
+        };
+    }) | ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }> & Omit<{
+            readonly disabled: boolean;
+            readonly error: boolean;
+            readonly readonly: string | boolean;
+            readonly defaultValue: string;
+            readonly allowClear: boolean;
+            readonly fitWidth: boolean;
+            readonly maxWFull: boolean;
+            readonly maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            readonly showWordLimit: boolean;
+            readonly autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+            readonly modelValue?: string | undefined;
+            readonly placeholder?: string | undefined;
+            readonly wordLength?: ((value: string) => number) | undefined;
+            readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+            readonly textareaAttrs?: Record<string, any> | undefined;
+            readonly onClear?: ((_ev: MouseEvent) => any) | undefined;
+            readonly onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            readonly onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            readonly onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            readonly onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "clear", _ev: MouseEvent) => void) & ((event: "focus", _ev: FocusEvent) => void) & ((event: "blur", _ev: FocusEvent) => void) & ((event: "change", _value: string, _ev: Event) => void) & ((event: "input", _value: string, _ev: Event) => void) & ((event: "update:modelValue", _value: string) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoSize: {
+                type: import("vue").PropType<boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                }>;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            textareaAttrs: {
+                type: import("vue").PropType<Record<string, any>>;
+            };
+        }>> & Readonly<{
+            onClear?: ((_ev: MouseEvent) => any) | undefined;
+            onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        }>, {
+            focus: () => void;
+            blur: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            clear: (_ev: MouseEvent) => any;
+            focus: (_ev: FocusEvent) => any;
+            blur: (_ev: FocusEvent) => any;
+            change: (_value: string, _ev: Event) => any;
+            input: (_value: string, _ev: Event) => any;
+            "update:modelValue": (_value: string) => any;
+        }, string, {
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        disabled: boolean;
+        error: boolean;
+        readonly: string | boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        fitWidth: boolean;
+        maxWFull: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+        autoSize: boolean | {
+            minRows?: number;
+            maxRows?: number;
+        };
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        placeholder: StringConstructor;
+        fitWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxWFull: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: (StringConstructor | BooleanConstructor)[];
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoSize: {
+            type: import("vue").PropType<boolean | {
+                minRows?: number;
+                maxRows?: number;
+            }>;
+            default: boolean;
+        };
+        wordLength: {
+            type: import("vue").PropType<(value: string) => number>;
+        };
+        wordSlice: {
+            type: import("vue").PropType<(value: string, maxLength: number) => string>;
+        };
+        textareaAttrs: {
+            type: import("vue").PropType<Record<string, any>>;
+        };
+    }>> & Readonly<{
+        onClear?: ((_ev: MouseEvent) => any) | undefined;
+        onFocus?: ((_ev: FocusEvent) => any) | undefined;
+        onBlur?: ((_ev: FocusEvent) => any) | undefined;
+        onChange?: ((_value: string, _ev: Event) => any) | undefined;
+        onInput?: ((_value: string, _ev: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+    }>, "focus" | "blur" | ("disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize")> & {
+        focus: () => void;
+        blur: () => void;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            suffix?: (props: {}) => any;
+        };
+    }) | undefined, ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }> & Omit<{
+            readonly type: "text" | "password";
+            readonly disabled: boolean;
+            readonly error: boolean;
+            readonly readonly: string | boolean;
+            readonly defaultValue: string;
+            readonly allowClear: boolean;
+            readonly fitWidth: boolean;
+            readonly maxWFull: boolean;
+            readonly maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            readonly showWordLimit: boolean;
+            readonly fitWidthFallback: string;
+            readonly size?: "small" | "medium" | "large" | "mini" | undefined;
+            readonly modelValue?: string | undefined;
+            readonly placeholder?: string | undefined;
+            readonly inputAttrs?: Record<string, any> | undefined;
+            readonly prepend?: string | undefined;
+            readonly append?: string | undefined;
+            readonly wordLength?: ((value: string) => number) | undefined;
+            readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+            readonly onClear?: ((_event: MouseEvent) => any) | undefined;
+            readonly onFocus?: ((_event: FocusEvent) => any) | undefined;
+            readonly onBlur?: ((_event: FocusEvent) => any) | undefined;
+            readonly onChange?: ((_value: string, _event: Event) => any) | undefined;
+            readonly onInput?: ((_value: string, _event: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            readonly onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "clear", _event: MouseEvent) => void) & ((event: "focus", _event: FocusEvent) => void) & ((event: "blur", _event: FocusEvent) => void) & ((event: "change", _value: string, _event: Event) => void) & ((event: "input", _value: string, _event: Event) => void) & ((event: "update:modelValue", _value: string) => void) & ((event: "pressEnter", _event: KeyboardEvent) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            size: import("vue").PropType<import("../index.ts").Size>;
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wordLength: import("vue").PropType<(value: string) => number>;
+            wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+            inputAttrs: ObjectConstructor;
+            type: {
+                type: import("vue").PropType<"text" | "password">;
+                default: string;
+            };
+            fitWidthFallback: {
+                type: StringConstructor;
+                default: string;
+            };
+            prepend: StringConstructor;
+            append: StringConstructor;
+        }>> & Readonly<{
+            onClear?: ((_event: MouseEvent) => any) | undefined;
+            onFocus?: ((_event: FocusEvent) => any) | undefined;
+            onBlur?: ((_event: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _event: Event) => any) | undefined;
+            onInput?: ((_value: string, _event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+            onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+        }>, {
+            inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            clear: (_event: MouseEvent) => void;
+            focus: (_event: FocusEvent) => void;
+            blur: (_event: FocusEvent) => void;
+            change: (_value: string, _event: Event) => void;
+            input: (_value: string, _event: Event) => void;
+            "update:modelValue": (_value: string) => void;
+            pressEnter: (_event: KeyboardEvent) => void;
+        }, string, {
+            type: "text" | "password";
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            fitWidthFallback: string;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        type: "text" | "password";
+        disabled: boolean;
+        error: boolean;
+        readonly: string | boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        fitWidth: boolean;
+        maxWFull: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+        fitWidthFallback: string;
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        size: import("vue").PropType<import("../index.ts").Size>;
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: (StringConstructor | BooleanConstructor)[];
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        placeholder: StringConstructor;
+        fitWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxWFull: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        wordLength: import("vue").PropType<(value: string) => number>;
+        wordSlice: import("vue").PropType<(value: string, maxLength: number) => string>;
+        inputAttrs: ObjectConstructor;
+        type: {
+            type: import("vue").PropType<"text" | "password">;
+            default: string;
+        };
+        fitWidthFallback: {
+            type: StringConstructor;
+            default: string;
+        };
+        prepend: StringConstructor;
+        append: StringConstructor;
+    }>> & Readonly<{
+        onClear?: ((_event: MouseEvent) => any) | undefined;
+        onFocus?: ((_event: FocusEvent) => any) | undefined;
+        onBlur?: ((_event: FocusEvent) => any) | undefined;
+        onChange?: ((_value: string, _event: Event) => any) | undefined;
+        onInput?: ((_value: string, _event: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        onPressEnter?: ((_event: KeyboardEvent) => any) | undefined;
+    }>, "focus" | "blur" | "inputRef" | ("type" | "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "fitWidthFallback")> & {
+        inputRef: HTMLInputElement | undefined;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            prepend?: (props: {}) => any;
+        } & {
+            append?: (props: {}) => any;
+        };
+    }) | ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }> & Omit<{
+            readonly disabled: boolean;
+            readonly error: boolean;
+            readonly readonly: string | boolean;
+            readonly defaultValue: string;
+            readonly allowClear: boolean;
+            readonly fitWidth: boolean;
+            readonly maxWFull: boolean;
+            readonly maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            readonly showWordLimit: boolean;
+            readonly autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+            readonly modelValue?: string | undefined;
+            readonly placeholder?: string | undefined;
+            readonly wordLength?: ((value: string) => number) | undefined;
+            readonly wordSlice?: ((value: string, maxLength: number) => string) | undefined;
+            readonly textareaAttrs?: Record<string, any> | undefined;
+            readonly onClear?: ((_ev: MouseEvent) => any) | undefined;
+            readonly onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            readonly onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            readonly onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            readonly onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "clear", _ev: MouseEvent) => void) & ((event: "focus", _ev: FocusEvent) => void) & ((event: "blur", _ev: FocusEvent) => void) & ((event: "change", _value: string, _ev: Event) => void) & ((event: "input", _value: string, _ev: Event) => void) & ((event: "update:modelValue", _value: string) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: StringConstructor;
+            defaultValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            placeholder: StringConstructor;
+            fitWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxWFull: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: (StringConstructor | BooleanConstructor)[];
+                default: boolean;
+            };
+            error: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxLength: {
+                type: import("vue").PropType<number | {
+                    length: number;
+                    errorOnly?: boolean;
+                }>;
+                default: number;
+            };
+            showWordLimit: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            allowClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoSize: {
+                type: import("vue").PropType<boolean | {
+                    minRows?: number;
+                    maxRows?: number;
+                }>;
+                default: boolean;
+            };
+            wordLength: {
+                type: import("vue").PropType<(value: string) => number>;
+            };
+            wordSlice: {
+                type: import("vue").PropType<(value: string, maxLength: number) => string>;
+            };
+            textareaAttrs: {
+                type: import("vue").PropType<Record<string, any>>;
+            };
+        }>> & Readonly<{
+            onClear?: ((_ev: MouseEvent) => any) | undefined;
+            onFocus?: ((_ev: FocusEvent) => any) | undefined;
+            onBlur?: ((_ev: FocusEvent) => any) | undefined;
+            onChange?: ((_value: string, _ev: Event) => any) | undefined;
+            onInput?: ((_value: string, _ev: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+        }>, {
+            focus: () => void;
+            blur: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            clear: (_ev: MouseEvent) => any;
+            focus: (_ev: FocusEvent) => any;
+            blur: (_ev: FocusEvent) => any;
+            change: (_value: string, _ev: Event) => any;
+            input: (_value: string, _ev: Event) => any;
+            "update:modelValue": (_value: string) => any;
+        }, string, {
+            disabled: boolean;
+            error: boolean;
+            readonly: string | boolean;
+            defaultValue: string;
+            allowClear: boolean;
+            fitWidth: boolean;
+            maxWFull: boolean;
+            maxLength: number | {
+                length: number;
+                errorOnly?: boolean;
+            };
+            showWordLimit: boolean;
+            autoSize: boolean | {
+                minRows?: number;
+                maxRows?: number;
+            };
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        disabled: boolean;
+        error: boolean;
+        readonly: string | boolean;
+        defaultValue: string;
+        allowClear: boolean;
+        fitWidth: boolean;
+        maxWFull: boolean;
+        maxLength: number | {
+            length: number;
+            errorOnly?: boolean;
+        };
+        showWordLimit: boolean;
+        autoSize: boolean | {
+            minRows?: number;
+            maxRows?: number;
+        };
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: StringConstructor;
+        defaultValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        placeholder: StringConstructor;
+        fitWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxWFull: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: (StringConstructor | BooleanConstructor)[];
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxLength: {
+            type: import("vue").PropType<number | {
+                length: number;
+                errorOnly?: boolean;
+            }>;
+            default: number;
+        };
+        showWordLimit: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoSize: {
+            type: import("vue").PropType<boolean | {
+                minRows?: number;
+                maxRows?: number;
+            }>;
+            default: boolean;
+        };
+        wordLength: {
+            type: import("vue").PropType<(value: string) => number>;
+        };
+        wordSlice: {
+            type: import("vue").PropType<(value: string, maxLength: number) => string>;
+        };
+        textareaAttrs: {
+            type: import("vue").PropType<Record<string, any>>;
+        };
+    }>> & Readonly<{
+        onClear?: ((_ev: MouseEvent) => any) | undefined;
+        onFocus?: ((_ev: FocusEvent) => any) | undefined;
+        onBlur?: ((_ev: FocusEvent) => any) | undefined;
+        onChange?: ((_value: string, _ev: Event) => any) | undefined;
+        onInput?: ((_value: string, _ev: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((_value: string) => any) | undefined;
+    }>, "focus" | "blur" | ("disabled" | "error" | "readonly" | "defaultValue" | "allowClear" | "fitWidth" | "maxWFull" | "maxLength" | "showWordLimit" | "autoSize")> & {
+        focus: () => void;
+        blur: () => void;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            suffix?: (props: {}) => any;
+        };
+    }) | undefined>;
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (_value: string, _prefix: string) => void;
+    clear: (_event: Event) => void;
+    focus: (_event: FocusEvent) => void;
+    blur: (_event: FocusEvent) => void;
+    change: (_value: string) => void;
+    select: (_value: string | number | Record<string, any> | undefined) => void;
+    "update:modelValue": (_value: string) => void;
 }, string, {
     type: "textarea" | "input";
     split: string;
     disabled: boolean;
     readonly: string | boolean;
-    data: (string | number | import("..").SelectOptionData | import("..").SelectOptionGroup)[];
+    data: (string | number | import("../index.ts").SelectOptionData | import("../index.ts").SelectOptionGroup)[];
     prefix: string | string[];
     defaultValue: string;
     allowClear: boolean;
     fitWidth: boolean;
     maxWFull: boolean;
-}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        option?: (props: {
+            data: {
+                [x: string]: unknown;
+                raw: {
+                    [x: string]: unknown;
+                    value?: import("../select/interface.ts").SelectOptionValue | undefined;
+                    label?: string | undefined;
+                    disabled?: boolean | undefined;
+                    tagProps?: Record<string, unknown> | undefined;
+                };
+                key: string;
+                index?: number | undefined;
+                origin: "options" | "extraOptions";
+                value: import("../select/interface.ts").SelectOptionValue;
+                label: string;
+                disabled?: boolean | undefined;
+                tagProps?: Record<string, unknown> | undefined;
+            } | undefined;
+        }) => any;
+    } & {
+        prefix?: (props: {}) => any;
+    } & {
+        suffix?: (props: {}) => any;
+    };
+}) & {
     install: (app: App, options?: SDOptions) => void;
 };
 export type MentionInstance = InstanceType<typeof _Mention>;