straw-ui-vue 0.1.21 → 0.1.22

package/dist/components/st-input/index.d.ts

@@ -12,46 +12,85 @@ export declare const StInput: {
         focus: () => void;
         blur: () => void;
         select: () => void;
-        inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
-            modelValue?: string | number;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string | number) => any;
-        }, import('vue').PublicProps, {
-            type: import('./types.d.ts').StInputType;
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
-            modelValue?: string | number;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
+        inputRef: import('vue').Ref<{
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }> & Omit<{
+                readonly type?: import('./types.d.ts').StInputType;
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly modelValue?: string | number;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string | number) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "disabled" | "placeholder" | "readonly">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string | number) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+                modelValue?: string | number;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string | number) => any;
+            }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string | number) => any;
+            }, string, {
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }, {}, 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: import('./types.d.ts').StInputType;
             disabled: boolean;
             placeholder: string;
             readonly: boolean;
-        }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupInputProps & {
             modelValue?: string | number;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -59,25 +98,92 @@ export declare const StInput: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string | number) => any;
-        }, import('vue').PublicProps, {
+        }>, keyof import('./types.d.ts').StInputGroupInputExpose | ("type" | "disabled" | "placeholder" | "readonly")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            inputRef: HTMLInputElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupInputSlots;
+        }, {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }> & Omit<{
+                readonly type?: import('./types.d.ts').StInputType;
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly modelValue?: string | number;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string | number) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "disabled" | "placeholder" | "readonly">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string | number) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+                modelValue?: string | number;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string | number) => any;
+            }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string | number) => any;
+            }, string, {
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }, {}, 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: import('./types.d.ts').StInputType;
             disabled: boolean;
             placeholder: string;
             readonly: boolean;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupInputProps & {
             modelValue?: string | number;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -85,12 +191,14 @@ export declare const StInput: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
-            type: import('./types.d.ts').StInputType;
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-        }>>;
+        }>, keyof import('./types.d.ts').StInputGroupInputExpose | ("type" | "disabled" | "placeholder" | "readonly")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            inputRef: HTMLInputElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupInputSlots;
+        }>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         clear: () => any;
         blur: (event: FocusEvent) => any;
@@ -126,46 +234,85 @@ export declare const StInput: {
         focus: () => void;
         blur: () => void;
         select: () => void;
-        inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
-            modelValue?: string | number;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string | number) => any;
-        }, import('vue').PublicProps, {
-            type: import('./types.d.ts').StInputType;
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
-            modelValue?: string | number;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
+        inputRef: import('vue').Ref<{
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }> & Omit<{
+                readonly type?: import('./types.d.ts').StInputType;
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly modelValue?: string | number;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string | number) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "disabled" | "placeholder" | "readonly">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string | number) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+                modelValue?: string | number;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string | number) => any;
+            }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string | number) => any;
+            }, string, {
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }, {}, 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: import('./types.d.ts').StInputType;
             disabled: boolean;
             placeholder: string;
             readonly: boolean;
-        }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupInputProps & {
             modelValue?: string | number;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -173,25 +320,92 @@ export declare const StInput: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string | number) => any;
-        }, import('vue').PublicProps, {
+        }>, keyof import('./types.d.ts').StInputGroupInputExpose | ("type" | "disabled" | "placeholder" | "readonly")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            inputRef: HTMLInputElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupInputSlots;
+        }, {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }> & Omit<{
+                readonly type?: import('./types.d.ts').StInputType;
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly modelValue?: string | number;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string | number) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "disabled" | "placeholder" | "readonly">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string | number) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+                modelValue?: string | number;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string | number) => any;
+            }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string | number) => any;
+            }, string, {
+                type: import('./types.d.ts').StInputType;
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+            }, {}, 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: import('./types.d.ts').StInputType;
             disabled: boolean;
             placeholder: string;
             readonly: boolean;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupInputProps & {
             modelValue?: string | number;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -199,12 +413,14 @@ export declare const StInput: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string | number) => any;
-        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
-            type: import('./types.d.ts').StInputType;
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-        }>>;
+        }>, keyof import('./types.d.ts').StInputGroupInputExpose | ("type" | "disabled" | "placeholder" | "readonly")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            inputRef: HTMLInputElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupInputSlots;
+        }>;
     }, {}, {}, {}, {
         type: import('./types.d.ts').StInputType;
         disabled: boolean;
@@ -230,33 +446,85 @@ export declare const StInput: {
     focus: () => void;
     blur: () => void;
     select: () => void;
-    inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
-        modelValue?: string | number;
-    }> & Readonly<{
-        onBlur?: (event: FocusEvent) => any;
-        onInput?: (event: Event) => any;
-        onFocus?: (event: FocusEvent) => any;
-        onChange?: (event: Event) => any;
-        "onUpdate:modelValue"?: (value: string | number) => any;
-    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (event: Event) => any;
-        focus: (event: FocusEvent) => any;
-        change: (event: Event) => any;
-        "update:modelValue": (value: string | number) => any;
-    }, import('vue').PublicProps, {
+    inputRef: import('vue').Ref<{
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            type: import('./types.d.ts').StInputType;
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+        }> & Omit<{
+            readonly type?: import('./types.d.ts').StInputType;
+            readonly placeholder?: string;
+            readonly disabled?: boolean;
+            readonly readonly?: boolean;
+            readonly maxlength?: number;
+            readonly minlength?: number;
+            readonly modelValue?: string | number;
+            readonly onBlur?: (event: FocusEvent) => any;
+            readonly onInput?: (event: Event) => any;
+            readonly onFocus?: (event: FocusEvent) => any;
+            readonly onChange?: (event: Event) => any;
+            readonly "onUpdate:modelValue"?: (value: string | number) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "disabled" | "placeholder" | "readonly">;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string | number) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+            modelValue?: string | number;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string | number) => any;
+        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string | number) => any;
+        }, string, {
+            type: import('./types.d.ts').StInputType;
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+        }, {}, 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: import('./types.d.ts').StInputType;
         disabled: boolean;
         placeholder: string;
         readonly: boolean;
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+    }> & Omit<Readonly<import('./types.d.ts').StInputGroupInputProps & {
         modelValue?: string | number;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -264,12 +532,92 @@ export declare const StInput: {
         onFocus?: (event: FocusEvent) => any;
         onChange?: (event: Event) => any;
         "onUpdate:modelValue"?: (value: string | number) => any;
-    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
+    }>, keyof import('./types.d.ts').StInputGroupInputExpose | ("type" | "disabled" | "placeholder" | "readonly")> & {
+        focus: () => void;
+        blur: () => void;
+        select: () => void;
+        inputRef: HTMLInputElement;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: import('./types.d.ts').StInputGroupInputSlots;
+    }, {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            type: import('./types.d.ts').StInputType;
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+        }> & Omit<{
+            readonly type?: import('./types.d.ts').StInputType;
+            readonly placeholder?: string;
+            readonly disabled?: boolean;
+            readonly readonly?: boolean;
+            readonly maxlength?: number;
+            readonly minlength?: number;
+            readonly modelValue?: string | number;
+            readonly onBlur?: (event: FocusEvent) => any;
+            readonly onInput?: (event: Event) => any;
+            readonly onFocus?: (event: FocusEvent) => any;
+            readonly onChange?: (event: Event) => any;
+            readonly "onUpdate:modelValue"?: (value: string | number) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "disabled" | "placeholder" | "readonly">;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string | number) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+            modelValue?: string | number;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string | number) => any;
+        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string | number) => any;
+        }, string, {
+            type: import('./types.d.ts').StInputType;
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+        }, {}, 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: import('./types.d.ts').StInputType;
         disabled: boolean;
         placeholder: string;
         readonly: boolean;
-    }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+    }> & Omit<Readonly<import('./types.d.ts').StInputGroupInputProps & {
         modelValue?: string | number;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -277,38 +625,14 @@ export declare const StInput: {
         onFocus?: (event: FocusEvent) => any;
         onChange?: (event: Event) => any;
         "onUpdate:modelValue"?: (value: string | number) => any;
-    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (event: Event) => any;
-        focus: (event: FocusEvent) => any;
-        change: (event: Event) => any;
-        "update:modelValue": (value: string | number) => any;
-    }, import('vue').PublicProps, {
-        type: import('./types.d.ts').StInputType;
-        disabled: boolean;
-        placeholder: string;
-        readonly: boolean;
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
-        modelValue?: string | number;
-    }> & Readonly<{
-        onBlur?: (event: FocusEvent) => any;
-        onInput?: (event: Event) => any;
-        onFocus?: (event: FocusEvent) => any;
-        onChange?: (event: Event) => any;
-        "onUpdate:modelValue"?: (value: string | number) => any;
-    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
-        type: import('./types.d.ts').StInputType;
-        disabled: boolean;
-        placeholder: string;
-        readonly: boolean;
-    }>>;
+    }>, keyof import('./types.d.ts').StInputGroupInputExpose | ("type" | "disabled" | "placeholder" | "readonly")> & {
+        focus: () => void;
+        blur: () => void;
+        select: () => void;
+        inputRef: HTMLInputElement;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: import('./types.d.ts').StInputGroupInputSlots;
+    }>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     clear: () => any;
     blur: (event: FocusEvent) => any;
@@ -404,15 +728,51 @@ export declare const StInput: {
     }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
         $slots: import('../st-button/types').StButtonSlots;
     });
-    StInputGroupInput: import('vue').DefineComponent<import('./types.d.ts').StInputGroupInputProps & {
-        modelValue?: string | number;
-    }, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (event: Event) => any;
-        focus: (event: FocusEvent) => any;
-        change: (event: Event) => any;
-        "update:modelValue": (value: string | number) => any;
-    }, string, import('vue').PublicProps, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+    StInputGroupInput: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+            modelValue?: string | number;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string | number) => any;
+        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string | number) => any;
+        }, import('vue').PublicProps, {
+            type: import('./types.d.ts').StInputType;
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+            modelValue?: string | number;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string | number) => any;
+        }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
+            type: import('./types.d.ts').StInputType;
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
         modelValue?: string | number;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -420,12 +780,20 @@ export declare const StInput: {
         onFocus?: (event: FocusEvent) => any;
         onChange?: (event: Event) => any;
         "onUpdate:modelValue"?: (value: string | number) => any;
-    }>, {
+    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        input: (event: Event) => any;
+        focus: (event: FocusEvent) => any;
+        change: (event: Event) => any;
+        "update:modelValue": (value: string | number) => any;
+    }, string, {
         type: import('./types.d.ts').StInputType;
         disabled: boolean;
         placeholder: string;
         readonly: boolean;
-    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: import('./types.d.ts').StInputGroupInputSlots;
+    });
     StInputGroupText: {
         new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupAddonProps> & Readonly<{
             onClick?: (event: MouseEvent) => any;
@@ -457,15 +825,51 @@ export declare const StInput: {
     }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
         $slots: import('./types.d.ts').StInputGroupAddonSlots;
     });
-    StInputGroupTextarea: import('vue').DefineComponent<import('./types.d.ts').StInputGroupTextareaProps & {
-        modelValue?: string;
-    }, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (event: Event) => any;
-        focus: (event: FocusEvent) => any;
-        change: (event: Event) => any;
-        "update:modelValue": (value: string) => any;
-    }, string, import('vue').PublicProps, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+    StInputGroupTextarea: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            modelValue?: string;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string) => any;
+        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string) => any;
+        }, import('vue').PublicProps, {
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+            rows: number;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            modelValue?: string;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string) => any;
+        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+            rows: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
         modelValue?: string;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -473,23 +877,69 @@ export declare const StInput: {
         onFocus?: (event: FocusEvent) => any;
         onChange?: (event: Event) => any;
         "onUpdate:modelValue"?: (value: string) => any;
-    }>, {
+    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        input: (event: Event) => any;
+        focus: (event: FocusEvent) => any;
+        change: (event: Event) => any;
+        "update:modelValue": (value: string) => any;
+    }, string, {
         disabled: boolean;
         placeholder: string;
         readonly: boolean;
         rows: number;
-    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-    StInputNumber: import('vue').DefineComponent<import('./types.d.ts').StInputNumberProps & {
-        modelValue?: number | undefined;
-    }, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (value: number) => any;
-        focus: (event: FocusEvent) => any;
-        change: (value: number) => any;
-        "update:modelValue": (value: number) => any;
-        increase: () => any;
-        decrease: () => any;
-    }, string, import('vue').PublicProps, Readonly<import('./types.d.ts').StInputNumberProps & {
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+    });
+    StInputNumber: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputNumberProps & {
+            modelValue?: number | undefined;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (value: number) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (value: number) => any;
+            "onUpdate:modelValue"?: (value: number) => any;
+            onIncrease?: () => any;
+            onDecrease?: () => any;
+        }>, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (value: number) => any;
+            focus: (event: FocusEvent) => any;
+            change: (value: number) => any;
+            "update:modelValue": (value: number) => any;
+            increase: () => any;
+            decrease: () => any;
+        }, import('vue').PublicProps, {
+            disabled: boolean;
+            controls: boolean;
+            step: number;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./types.d.ts').StInputNumberProps & {
+            modelValue?: number | undefined;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (value: number) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (value: number) => any;
+            "onUpdate:modelValue"?: (value: number) => any;
+            onIncrease?: () => any;
+            onDecrease?: () => any;
+        }>, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, {
+            disabled: boolean;
+            controls: boolean;
+            step: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputNumberProps & {
         modelValue?: number | undefined;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -499,11 +949,21 @@ export declare const StInput: {
         "onUpdate:modelValue"?: (value: number) => any;
         onIncrease?: () => any;
         onDecrease?: () => any;
-    }>, {
+    }>, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        input: (value: number) => any;
+        focus: (event: FocusEvent) => any;
+        change: (value: number) => any;
+        "update:modelValue": (value: number) => any;
+        increase: () => any;
+        decrease: () => any;
+    }, string, {
         disabled: boolean;
-        step: number;
         controls: boolean;
-    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        step: number;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: import('./types.d.ts').StInputNumberSlots;
+    });
     StTextarea: {
         new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StTextareaProps & {
             modelValue?: string;
@@ -518,46 +978,86 @@ export declare const StInput: {
             focus: () => void;
             blur: () => void;
             select: () => void;
-            inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-                modelValue?: string;
-            }> & Readonly<{
-                onBlur?: (event: FocusEvent) => any;
-                onInput?: (event: Event) => any;
-                onFocus?: (event: FocusEvent) => any;
-                onChange?: (event: Event) => any;
-                "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                blur: (event: FocusEvent) => any;
-                input: (event: Event) => any;
-                focus: (event: FocusEvent) => any;
-                change: (event: Event) => any;
-                "update:modelValue": (value: string) => any;
-            }, import('vue').PublicProps, {
-                disabled: boolean;
-                placeholder: string;
-                readonly: boolean;
-                rows: number;
-            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-                modelValue?: string;
-            }> & Readonly<{
-                onBlur?: (event: FocusEvent) => any;
-                onInput?: (event: Event) => any;
-                onFocus?: (event: FocusEvent) => any;
-                onChange?: (event: Event) => any;
-                "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+            inputRef: import('vue').Ref<{
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: number;
+                }> & Omit<{
+                    readonly placeholder?: string;
+                    readonly disabled?: boolean;
+                    readonly readonly?: boolean;
+                    readonly maxlength?: number;
+                    readonly minlength?: number;
+                    readonly rows?: number;
+                    readonly cols?: number;
+                    readonly modelValue?: string;
+                    readonly onBlur?: (event: FocusEvent) => any;
+                    readonly onInput?: (event: Event) => any;
+                    readonly onFocus?: (event: FocusEvent) => any;
+                    readonly onChange?: (event: Event) => any;
+                    readonly "onUpdate:modelValue"?: (value: string) => any;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+                $attrs: import('vue').Attrs;
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any>;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                    modelValue?: string;
+                }> & Readonly<{
+                    onBlur?: (event: FocusEvent) => any;
+                    onInput?: (event: Event) => any;
+                    onFocus?: (event: FocusEvent) => any;
+                    onChange?: (event: Event) => any;
+                    "onUpdate:modelValue"?: (value: string) => any;
+                }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    blur: (event: FocusEvent) => any;
+                    input: (event: Event) => any;
+                    focus: (event: FocusEvent) => any;
+                    change: (event: Event) => any;
+                    "update:modelValue": (value: string) => any;
+                }, string, {
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: 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;
                 placeholder: string;
                 readonly: boolean;
                 rows: number;
-            }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
                 modelValue?: string;
             }> & Readonly<{
                 onBlur?: (event: FocusEvent) => any;
@@ -565,25 +1065,93 @@ export declare const StInput: {
                 onFocus?: (event: FocusEvent) => any;
                 onChange?: (event: Event) => any;
                 "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                blur: (event: FocusEvent) => any;
-                input: (event: Event) => any;
-                focus: (event: FocusEvent) => any;
-                change: (event: Event) => any;
-                "update:modelValue": (value: string) => any;
-            }, import('vue').PublicProps, {
+            }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+                focus: () => void;
+                blur: () => void;
+                select: () => void;
+                textareaRef: HTMLTextAreaElement;
+            } & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+            }, {
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: number;
+                }> & Omit<{
+                    readonly placeholder?: string;
+                    readonly disabled?: boolean;
+                    readonly readonly?: boolean;
+                    readonly maxlength?: number;
+                    readonly minlength?: number;
+                    readonly rows?: number;
+                    readonly cols?: number;
+                    readonly modelValue?: string;
+                    readonly onBlur?: (event: FocusEvent) => any;
+                    readonly onInput?: (event: Event) => any;
+                    readonly onFocus?: (event: FocusEvent) => any;
+                    readonly onChange?: (event: Event) => any;
+                    readonly "onUpdate:modelValue"?: (value: string) => any;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+                $attrs: import('vue').Attrs;
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any>;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                    modelValue?: string;
+                }> & Readonly<{
+                    onBlur?: (event: FocusEvent) => any;
+                    onInput?: (event: Event) => any;
+                    onFocus?: (event: FocusEvent) => any;
+                    onChange?: (event: Event) => any;
+                    "onUpdate:modelValue"?: (value: string) => any;
+                }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    blur: (event: FocusEvent) => any;
+                    input: (event: Event) => any;
+                    focus: (event: FocusEvent) => any;
+                    change: (event: Event) => any;
+                    "update:modelValue": (value: string) => any;
+                }, string, {
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: 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;
                 placeholder: string;
                 readonly: boolean;
                 rows: number;
-            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
                 modelValue?: string;
             }> & Readonly<{
                 onBlur?: (event: FocusEvent) => any;
@@ -591,12 +1159,14 @@ export declare const StInput: {
                 onFocus?: (event: FocusEvent) => any;
                 onChange?: (event: Event) => any;
                 "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
-                disabled: boolean;
-                placeholder: string;
-                readonly: boolean;
-                rows: number;
-            }>>;
+            }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+                focus: () => void;
+                blur: () => void;
+                select: () => void;
+                textareaRef: HTMLTextAreaElement;
+            } & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+            }>;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             clear: () => any;
             blur: (event: FocusEvent) => any;
@@ -631,46 +1201,86 @@ export declare const StInput: {
             focus: () => void;
             blur: () => void;
             select: () => void;
-            inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-                modelValue?: string;
-            }> & Readonly<{
-                onBlur?: (event: FocusEvent) => any;
-                onInput?: (event: Event) => any;
-                onFocus?: (event: FocusEvent) => any;
-                onChange?: (event: Event) => any;
-                "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                blur: (event: FocusEvent) => any;
-                input: (event: Event) => any;
-                focus: (event: FocusEvent) => any;
-                change: (event: Event) => any;
-                "update:modelValue": (value: string) => any;
-            }, import('vue').PublicProps, {
-                disabled: boolean;
-                placeholder: string;
-                readonly: boolean;
-                rows: number;
-            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-                modelValue?: string;
-            }> & Readonly<{
-                onBlur?: (event: FocusEvent) => any;
-                onInput?: (event: Event) => any;
-                onFocus?: (event: FocusEvent) => any;
-                onChange?: (event: Event) => any;
-                "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+            inputRef: import('vue').Ref<{
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: number;
+                }> & Omit<{
+                    readonly placeholder?: string;
+                    readonly disabled?: boolean;
+                    readonly readonly?: boolean;
+                    readonly maxlength?: number;
+                    readonly minlength?: number;
+                    readonly rows?: number;
+                    readonly cols?: number;
+                    readonly modelValue?: string;
+                    readonly onBlur?: (event: FocusEvent) => any;
+                    readonly onInput?: (event: Event) => any;
+                    readonly onFocus?: (event: FocusEvent) => any;
+                    readonly onChange?: (event: Event) => any;
+                    readonly "onUpdate:modelValue"?: (value: string) => any;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+                $attrs: import('vue').Attrs;
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any>;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                    modelValue?: string;
+                }> & Readonly<{
+                    onBlur?: (event: FocusEvent) => any;
+                    onInput?: (event: Event) => any;
+                    onFocus?: (event: FocusEvent) => any;
+                    onChange?: (event: Event) => any;
+                    "onUpdate:modelValue"?: (value: string) => any;
+                }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    blur: (event: FocusEvent) => any;
+                    input: (event: Event) => any;
+                    focus: (event: FocusEvent) => any;
+                    change: (event: Event) => any;
+                    "update:modelValue": (value: string) => any;
+                }, string, {
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: 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;
                 placeholder: string;
                 readonly: boolean;
                 rows: number;
-            }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
                 modelValue?: string;
             }> & Readonly<{
                 onBlur?: (event: FocusEvent) => any;
@@ -678,25 +1288,93 @@ export declare const StInput: {
                 onFocus?: (event: FocusEvent) => any;
                 onChange?: (event: Event) => any;
                 "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                blur: (event: FocusEvent) => any;
-                input: (event: Event) => any;
-                focus: (event: FocusEvent) => any;
-                change: (event: Event) => any;
-                "update:modelValue": (value: string) => any;
-            }, import('vue').PublicProps, {
+            }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+                focus: () => void;
+                blur: () => void;
+                select: () => void;
+                textareaRef: HTMLTextAreaElement;
+            } & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+            }, {
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: number;
+                }> & Omit<{
+                    readonly placeholder?: string;
+                    readonly disabled?: boolean;
+                    readonly readonly?: boolean;
+                    readonly maxlength?: number;
+                    readonly minlength?: number;
+                    readonly rows?: number;
+                    readonly cols?: number;
+                    readonly modelValue?: string;
+                    readonly onBlur?: (event: FocusEvent) => any;
+                    readonly onInput?: (event: Event) => any;
+                    readonly onFocus?: (event: FocusEvent) => any;
+                    readonly onChange?: (event: Event) => any;
+                    readonly "onUpdate:modelValue"?: (value: string) => any;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+                $attrs: import('vue').Attrs;
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any>;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                    modelValue?: string;
+                }> & Readonly<{
+                    onBlur?: (event: FocusEvent) => any;
+                    onInput?: (event: Event) => any;
+                    onFocus?: (event: FocusEvent) => any;
+                    onChange?: (event: Event) => any;
+                    "onUpdate:modelValue"?: (value: string) => any;
+                }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    blur: (event: FocusEvent) => any;
+                    input: (event: Event) => any;
+                    focus: (event: FocusEvent) => any;
+                    change: (event: Event) => any;
+                    "update:modelValue": (value: string) => any;
+                }, string, {
+                    disabled: boolean;
+                    placeholder: string;
+                    readonly: boolean;
+                    rows: 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;
                 placeholder: string;
                 readonly: boolean;
                 rows: number;
-            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-                P: {};
-                B: {};
-                D: {};
-                C: {};
-                M: {};
-                Defaults: {};
-            }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
                 modelValue?: string;
             }> & Readonly<{
                 onBlur?: (event: FocusEvent) => any;
@@ -704,12 +1382,14 @@ export declare const StInput: {
                 onFocus?: (event: FocusEvent) => any;
                 onChange?: (event: Event) => any;
                 "onUpdate:modelValue"?: (value: string) => any;
-            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
-                disabled: boolean;
-                placeholder: string;
-                readonly: boolean;
-                rows: number;
-            }>>;
+            }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+                focus: () => void;
+                blur: () => void;
+                select: () => void;
+                textareaRef: HTMLTextAreaElement;
+            } & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+            }>;
         }, {}, {}, {}, {
             disabled: boolean;
             placeholder: string;
@@ -734,46 +1414,86 @@ export declare const StInput: {
         focus: () => void;
         blur: () => void;
         select: () => void;
-        inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-            modelValue?: string;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-            rows: number;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-            modelValue?: string;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+        inputRef: import('vue').Ref<{
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: number;
+            }> & Omit<{
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly rows?: number;
+                readonly cols?: number;
+                readonly modelValue?: string;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                modelValue?: string;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string) => any;
+            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: 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;
             placeholder: string;
             readonly: boolean;
             rows: number;
-        }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
             modelValue?: string;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -781,25 +1501,93 @@ export declare const StInput: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {
+        }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            textareaRef: HTMLTextAreaElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+        }, {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: number;
+            }> & Omit<{
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly rows?: number;
+                readonly cols?: number;
+                readonly modelValue?: string;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                modelValue?: string;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string) => any;
+            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: 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;
             placeholder: string;
             readonly: boolean;
             rows: number;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
             modelValue?: string;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -807,12 +1595,14 @@ export declare const StInput: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-            rows: number;
-        }>>;
+        }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            textareaRef: HTMLTextAreaElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+        }>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         clear: () => any;
         blur: (event: FocusEvent) => any;
@@ -908,15 +1698,51 @@ export declare const StInputGroupButton: {
 }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: import('../st-button/types').StButtonSlots;
 });
-export declare const StInputGroupInput: import('vue').DefineComponent<import('./types.d.ts').StInputGroupInputProps & {
-    modelValue?: string | number;
-}, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    blur: (event: FocusEvent) => any;
-    input: (event: Event) => any;
-    focus: (event: FocusEvent) => any;
-    change: (event: Event) => any;
-    "update:modelValue": (value: string | number) => any;
-}, string, import('vue').PublicProps, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+export declare const StInputGroupInput: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupInputProps & {
+        modelValue?: string | number;
+    }> & Readonly<{
+        onBlur?: (event: FocusEvent) => any;
+        onInput?: (event: Event) => any;
+        onFocus?: (event: FocusEvent) => any;
+        onChange?: (event: Event) => any;
+        "onUpdate:modelValue"?: (value: string | number) => any;
+    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        input: (event: Event) => any;
+        focus: (event: FocusEvent) => any;
+        change: (event: Event) => any;
+        "update:modelValue": (value: string | number) => any;
+    }, import('vue').PublicProps, {
+        type: import('./types.d.ts').StInputType;
+        disabled: boolean;
+        placeholder: string;
+        readonly: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./types.d.ts').StInputGroupInputProps & {
+        modelValue?: string | number;
+    }> & Readonly<{
+        onBlur?: (event: FocusEvent) => any;
+        onInput?: (event: Event) => any;
+        onFocus?: (event: FocusEvent) => any;
+        onChange?: (event: Event) => any;
+        "onUpdate:modelValue"?: (value: string | number) => any;
+    }>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, {
+        type: import('./types.d.ts').StInputType;
+        disabled: boolean;
+        placeholder: string;
+        readonly: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupInputProps & {
     modelValue?: string | number;
 }> & Readonly<{
     onBlur?: (event: FocusEvent) => any;
@@ -924,12 +1750,20 @@ export declare const StInputGroupInput: import('vue').DefineComponent<import('./
     onFocus?: (event: FocusEvent) => any;
     onChange?: (event: Event) => any;
     "onUpdate:modelValue"?: (value: string | number) => any;
-}>, {
+}>, import('./types.d.ts').StInputGroupInputExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    input: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    "update:modelValue": (value: string | number) => any;
+}, string, {
     type: import('./types.d.ts').StInputType;
     disabled: boolean;
     placeholder: string;
     readonly: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: import('./types.d.ts').StInputGroupInputSlots;
+});
 export declare const StInputGroupText: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupAddonProps> & Readonly<{
         onClick?: (event: MouseEvent) => any;
@@ -961,15 +1795,51 @@ export declare const StInputGroupText: {
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: import('./types.d.ts').StInputGroupAddonSlots;
 });
-export declare const StInputGroupTextarea: import('vue').DefineComponent<import('./types.d.ts').StInputGroupTextareaProps & {
-    modelValue?: string;
-}, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    blur: (event: FocusEvent) => any;
-    input: (event: Event) => any;
-    focus: (event: FocusEvent) => any;
-    change: (event: Event) => any;
-    "update:modelValue": (value: string) => any;
-}, string, import('vue').PublicProps, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+export declare const StInputGroupTextarea: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        modelValue?: string;
+    }> & Readonly<{
+        onBlur?: (event: FocusEvent) => any;
+        onInput?: (event: Event) => any;
+        onFocus?: (event: FocusEvent) => any;
+        onChange?: (event: Event) => any;
+        "onUpdate:modelValue"?: (value: string) => any;
+    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        input: (event: Event) => any;
+        focus: (event: FocusEvent) => any;
+        change: (event: Event) => any;
+        "update:modelValue": (value: string) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        placeholder: string;
+        readonly: boolean;
+        rows: number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        modelValue?: string;
+    }> & Readonly<{
+        onBlur?: (event: FocusEvent) => any;
+        onInput?: (event: Event) => any;
+        onFocus?: (event: FocusEvent) => any;
+        onChange?: (event: Event) => any;
+        "onUpdate:modelValue"?: (value: string) => any;
+    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+        disabled: boolean;
+        placeholder: string;
+        readonly: boolean;
+        rows: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
     modelValue?: string;
 }> & Readonly<{
     onBlur?: (event: FocusEvent) => any;
@@ -977,91 +1847,187 @@ export declare const StInputGroupTextarea: import('vue').DefineComponent<import(
     onFocus?: (event: FocusEvent) => any;
     onChange?: (event: Event) => any;
     "onUpdate:modelValue"?: (value: string) => any;
-}>, {
+}>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    input: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    "update:modelValue": (value: string) => any;
+}, string, {
     disabled: boolean;
     placeholder: string;
     readonly: boolean;
     rows: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export declare const StInputNumber: import('vue').DefineComponent<import('./types.d.ts').StInputNumberProps & {
-    modelValue?: number | undefined;
-}, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    blur: (event: FocusEvent) => any;
-    input: (value: number) => any;
-    focus: (event: FocusEvent) => any;
-    change: (value: number) => any;
-    "update:modelValue": (value: number) => any;
-    increase: () => any;
-    decrease: () => any;
-}, string, import('vue').PublicProps, Readonly<import('./types.d.ts').StInputNumberProps & {
-    modelValue?: number | undefined;
-}> & Readonly<{
-    onBlur?: (event: FocusEvent) => any;
-    onInput?: (value: number) => any;
-    onFocus?: (event: FocusEvent) => any;
-    onChange?: (value: number) => any;
-    "onUpdate:modelValue"?: (value: number) => any;
-    onIncrease?: () => any;
-    onDecrease?: () => any;
-}>, {
-    disabled: boolean;
-    step: number;
-    controls: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-export declare const StTextarea: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StTextareaProps & {
-        modelValue?: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+});
+export declare const StInputNumber: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputNumberProps & {
+        modelValue?: number | undefined;
     }> & Readonly<{
-        onClear?: () => any;
         onBlur?: (event: FocusEvent) => any;
-        onInput?: (event: Event) => any;
+        onInput?: (value: number) => any;
         onFocus?: (event: FocusEvent) => any;
-        onChange?: (event: Event) => any;
-        "onUpdate:modelValue"?: (value: string) => any;
-    }>, {
-        focus: () => void;
-        blur: () => void;
-        select: () => void;
-        inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-            modelValue?: string;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-            rows: number;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-            modelValue?: string;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+        onChange?: (value: number) => any;
+        "onUpdate:modelValue"?: (value: number) => any;
+        onIncrease?: () => any;
+        onDecrease?: () => any;
+    }>, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        input: (value: number) => any;
+        focus: (event: FocusEvent) => any;
+        change: (value: number) => any;
+        "update:modelValue": (value: number) => any;
+        increase: () => any;
+        decrease: () => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        controls: boolean;
+        step: number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./types.d.ts').StInputNumberProps & {
+        modelValue?: number | undefined;
+    }> & Readonly<{
+        onBlur?: (event: FocusEvent) => any;
+        onInput?: (value: number) => any;
+        onFocus?: (event: FocusEvent) => any;
+        onChange?: (value: number) => any;
+        "onUpdate:modelValue"?: (value: number) => any;
+        onIncrease?: () => any;
+        onDecrease?: () => any;
+    }>, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, {
+        disabled: boolean;
+        controls: boolean;
+        step: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputNumberProps & {
+    modelValue?: number | undefined;
+}> & Readonly<{
+    onBlur?: (event: FocusEvent) => any;
+    onInput?: (value: number) => any;
+    onFocus?: (event: FocusEvent) => any;
+    onChange?: (value: number) => any;
+    "onUpdate:modelValue"?: (value: number) => any;
+    onIncrease?: () => any;
+    onDecrease?: () => any;
+}>, import('./types.d.ts').StInputNumberExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    input: (value: number) => any;
+    focus: (event: FocusEvent) => any;
+    change: (value: number) => any;
+    "update:modelValue": (value: number) => any;
+    increase: () => any;
+    decrease: () => any;
+}, string, {
+    disabled: boolean;
+    controls: boolean;
+    step: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: import('./types.d.ts').StInputNumberSlots;
+});
+export declare const StTextarea: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StTextareaProps & {
+        modelValue?: string;
+    }> & Readonly<{
+        onClear?: () => any;
+        onBlur?: (event: FocusEvent) => any;
+        onInput?: (event: Event) => any;
+        onFocus?: (event: FocusEvent) => any;
+        onChange?: (event: Event) => any;
+        "onUpdate:modelValue"?: (value: string) => any;
+    }>, {
+        focus: () => void;
+        blur: () => void;
+        select: () => void;
+        inputRef: import('vue').Ref<{
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: number;
+            }> & Omit<{
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly rows?: number;
+                readonly cols?: number;
+                readonly modelValue?: string;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                modelValue?: string;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string) => any;
+            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: 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;
             placeholder: string;
             readonly: boolean;
             rows: number;
-        }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
             modelValue?: string;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -1069,25 +2035,93 @@ export declare const StTextarea: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {
+        }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            textareaRef: HTMLTextAreaElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+        }, {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: number;
+            }> & Omit<{
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly rows?: number;
+                readonly cols?: number;
+                readonly modelValue?: string;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                modelValue?: string;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string) => any;
+            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: 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;
             placeholder: string;
             readonly: boolean;
             rows: number;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
             modelValue?: string;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -1095,12 +2129,14 @@ export declare const StTextarea: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-            rows: number;
-        }>>;
+        }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            textareaRef: HTMLTextAreaElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+        }>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         clear: () => any;
         blur: (event: FocusEvent) => any;
@@ -1135,46 +2171,86 @@ export declare const StTextarea: {
         focus: () => void;
         blur: () => void;
         select: () => void;
-        inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-            modelValue?: string;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-            rows: number;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-            modelValue?: string;
-        }> & Readonly<{
-            onBlur?: (event: FocusEvent) => any;
-            onInput?: (event: Event) => any;
-            onFocus?: (event: FocusEvent) => any;
-            onChange?: (event: Event) => any;
-            "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+        inputRef: import('vue').Ref<{
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: number;
+            }> & Omit<{
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly rows?: number;
+                readonly cols?: number;
+                readonly modelValue?: string;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                modelValue?: string;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string) => any;
+            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: 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;
             placeholder: string;
             readonly: boolean;
             rows: number;
-        }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
             modelValue?: string;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -1182,25 +2258,93 @@ export declare const StTextarea: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            blur: (event: FocusEvent) => any;
-            input: (event: Event) => any;
-            focus: (event: FocusEvent) => any;
-            change: (event: Event) => any;
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {
+        }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            textareaRef: HTMLTextAreaElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+        }, {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: number;
+            }> & Omit<{
+                readonly placeholder?: string;
+                readonly disabled?: boolean;
+                readonly readonly?: boolean;
+                readonly maxlength?: number;
+                readonly minlength?: number;
+                readonly rows?: number;
+                readonly cols?: number;
+                readonly modelValue?: string;
+                readonly onBlur?: (event: FocusEvent) => any;
+                readonly onInput?: (event: Event) => any;
+                readonly onFocus?: (event: FocusEvent) => any;
+                readonly onChange?: (event: Event) => any;
+                readonly "onUpdate:modelValue"?: (value: string) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+                modelValue?: string;
+            }> & Readonly<{
+                onBlur?: (event: FocusEvent) => any;
+                onInput?: (event: Event) => any;
+                onFocus?: (event: FocusEvent) => any;
+                onChange?: (event: Event) => any;
+                "onUpdate:modelValue"?: (value: string) => any;
+            }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                input: (event: Event) => any;
+                focus: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                disabled: boolean;
+                placeholder: string;
+                readonly: boolean;
+                rows: 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;
             placeholder: string;
             readonly: boolean;
             rows: number;
-        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+        }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
             modelValue?: string;
         }> & Readonly<{
             onBlur?: (event: FocusEvent) => any;
@@ -1208,12 +2352,14 @@ export declare const StTextarea: {
             onFocus?: (event: FocusEvent) => any;
             onChange?: (event: Event) => any;
             "onUpdate:modelValue"?: (value: string) => any;
-        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
-            disabled: boolean;
-            placeholder: string;
-            readonly: boolean;
-            rows: number;
-        }>>;
+        }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+            focus: () => void;
+            blur: () => void;
+            select: () => void;
+            textareaRef: HTMLTextAreaElement;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+        }>;
     }, {}, {}, {}, {
         disabled: boolean;
         placeholder: string;
@@ -1238,46 +2384,86 @@ export declare const StTextarea: {
     focus: () => void;
     blur: () => void;
     select: () => void;
-    inputRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-        modelValue?: string;
-    }> & Readonly<{
-        onBlur?: (event: FocusEvent) => any;
-        onInput?: (event: Event) => any;
-        onFocus?: (event: FocusEvent) => any;
-        onChange?: (event: Event) => any;
-        "onUpdate:modelValue"?: (value: string) => any;
-    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (event: Event) => any;
-        focus: (event: FocusEvent) => any;
-        change: (event: Event) => any;
-        "update:modelValue": (value: string) => any;
-    }, import('vue').PublicProps, {
-        disabled: boolean;
-        placeholder: string;
-        readonly: boolean;
-        rows: number;
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
-        modelValue?: string;
-    }> & Readonly<{
-        onBlur?: (event: FocusEvent) => any;
-        onInput?: (event: Event) => any;
-        onFocus?: (event: FocusEvent) => any;
-        onChange?: (event: Event) => any;
-        "onUpdate:modelValue"?: (value: string) => any;
-    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
+    inputRef: import('vue').Ref<{
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+            rows: number;
+        }> & Omit<{
+            readonly placeholder?: string;
+            readonly disabled?: boolean;
+            readonly readonly?: boolean;
+            readonly maxlength?: number;
+            readonly minlength?: number;
+            readonly rows?: number;
+            readonly cols?: number;
+            readonly modelValue?: string;
+            readonly onBlur?: (event: FocusEvent) => any;
+            readonly onInput?: (event: Event) => any;
+            readonly onFocus?: (event: FocusEvent) => any;
+            readonly onChange?: (event: Event) => any;
+            readonly "onUpdate:modelValue"?: (value: string) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            modelValue?: string;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string) => any;
+        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string) => any;
+        }, string, {
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+            rows: 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;
         placeholder: string;
         readonly: boolean;
         rows: number;
-    }>, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+    }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
         modelValue?: string;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -1285,25 +2471,93 @@ export declare const StTextarea: {
         onFocus?: (event: FocusEvent) => any;
         onChange?: (event: Event) => any;
         "onUpdate:modelValue"?: (value: string) => any;
-    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-        blur: (event: FocusEvent) => any;
-        input: (event: Event) => any;
-        focus: (event: FocusEvent) => any;
-        change: (event: Event) => any;
-        "update:modelValue": (value: string) => any;
-    }, import('vue').PublicProps, {
+    }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+        focus: () => void;
+        blur: () => void;
+        select: () => void;
+        textareaRef: HTMLTextAreaElement;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+    }, {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+            rows: number;
+        }> & Omit<{
+            readonly placeholder?: string;
+            readonly disabled?: boolean;
+            readonly readonly?: boolean;
+            readonly maxlength?: number;
+            readonly minlength?: number;
+            readonly rows?: number;
+            readonly cols?: number;
+            readonly modelValue?: string;
+            readonly onBlur?: (event: FocusEvent) => any;
+            readonly onInput?: (event: Event) => any;
+            readonly onFocus?: (event: FocusEvent) => any;
+            readonly onChange?: (event: Event) => any;
+            readonly "onUpdate:modelValue"?: (value: string) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "disabled" | "placeholder" | "readonly" | "rows">;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "input", event: Event) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+            modelValue?: string;
+        }> & Readonly<{
+            onBlur?: (event: FocusEvent) => any;
+            onInput?: (event: Event) => any;
+            onFocus?: (event: FocusEvent) => any;
+            onChange?: (event: Event) => any;
+            "onUpdate:modelValue"?: (value: string) => any;
+        }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            input: (event: Event) => any;
+            focus: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string) => any;
+        }, string, {
+            disabled: boolean;
+            placeholder: string;
+            readonly: boolean;
+            rows: 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;
         placeholder: string;
         readonly: boolean;
         rows: number;
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
+    }> & Omit<Readonly<import('./types.d.ts').StInputGroupTextareaProps & {
         modelValue?: string;
     }> & Readonly<{
         onBlur?: (event: FocusEvent) => any;
@@ -1311,12 +2565,14 @@ export declare const StTextarea: {
         onFocus?: (event: FocusEvent) => any;
         onChange?: (event: Event) => any;
         "onUpdate:modelValue"?: (value: string) => any;
-    }>, import('./types.d.ts').StInputGroupTextareaExpose, {}, {}, {}, {
-        disabled: boolean;
-        placeholder: string;
-        readonly: boolean;
-        rows: number;
-    }>>;
+    }>, keyof import('./types.d.ts').StInputGroupTextareaExpose | ("disabled" | "placeholder" | "readonly" | "rows")> & {
+        focus: () => void;
+        blur: () => void;
+        select: () => void;
+        textareaRef: HTMLTextAreaElement;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: import('./types.d.ts').StInputGroupTextareaSlots;
+    }>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     clear: () => any;
     blur: (event: FocusEvent) => any;