npm - @pantograph/vue - Versions diffs - 0.17.0 → 0.18.0 - Mend

@pantograph/vue 0.17.0 → 0.18.0

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

Files changed (167) hide show

package/dist/Textarea/Textarea.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { nextTick } from 'vue';
-import { Class } from '../types';
 import { TextareaSize, TextareaStatus } from './Textarea.model';
+import { Class } from '../types';
 export interface TextareaProps {
     id?: string;
     maxlength?: number;
@@ -13,12 +13,14 @@ export interface TextareaProps {
     clearIcon?: string;
     clearIconCls?: Class;
     class?: Class;
-    rootCls?: Class;
+    textareaCls?: Class;
     allowClear?: boolean;
     bordered?: boolean;
     autoSize?: boolean;
     size?: TextareaSize;
     status?: TextareaStatus;
+    rootProps?: object;
+    height?: string | number;
 }
 export interface TextareaSlots {
     clearIcon?: () => never;
@@ -56,6 +58,425 @@ declare function __VLS_template(): {
             };
             $refs: {
                 [x: string]: unknown;
+            } & {
+                root: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                        scrollHideDelay: number;
+                    }> & Omit<{
+                        readonly type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                        readonly scrollHideDelay: number;
+                        readonly dir?: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction | undefined;
+                        readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "scrollHideDelay">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        dir: {
+                            type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                        };
+                        type: {
+                            type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                            default: string;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        };
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        scrollHideDelay: {
+                            type: import('vue').PropType<number>;
+                            default: number;
+                        };
+                    }>>, {
+                        viewport: import('vue').Ref<HTMLElement | undefined>;
+                        scrollTop: () => void;
+                        scrollTopLeft: () => void;
+                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                        scrollHideDelay: 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 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('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: number;
+                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    dir: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                    };
+                    type: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                        default: string;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    scrollHideDelay: {
+                        type: import('vue').PropType<number>;
+                        default: number;
+                    };
+                }>>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+                    viewport: import('vue').Ref<HTMLElement | undefined>;
+                    scrollTop: () => void;
+                    scrollTopLeft: () => void;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                    };
+                }) | null;
+                container: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{
+                        readonly nonce?: string | undefined;
+                        readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        nonce: {
+                            type: import('vue').PropType<string>;
+                        };
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        };
+                    }>>, {
+                        viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    nonce: {
+                        type: import('vue').PropType<string>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+                    viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                    };
+                }) | null;
+                wrap: HTMLDivElement;
+                top: HTMLDivElement;
+                end: HTMLDivElement;
+                start: HTMLDivElement;
+                bottom: HTMLDivElement;
+                vertical: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        as: import('radix-vue').AsTag | import('vue').Component;
+                        orientation: "vertical" | "horizontal";
+                    }> & Omit<{
+                        readonly as: import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component;
+                        readonly orientation: "vertical" | "horizontal";
+                        readonly forceMount?: boolean | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "as" | "orientation">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                            default: string;
+                        };
+                        forceMount: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        orientation: {
+                            type: import('vue').PropType<"horizontal" | "vertical">;
+                            default: string;
+                        };
+                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        as: import('radix-vue').AsTag | import('vue').Component;
+                        orientation: "vertical" | "horizontal";
+                    }, {}, 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 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<{
+                    as: import('radix-vue').AsTag | import('vue').Component;
+                    orientation: "vertical" | "horizontal";
+                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        default: string;
+                    };
+                    forceMount: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    orientation: {
+                        type: import('vue').PropType<"horizontal" | "vertical">;
+                        default: string;
+                    };
+                }>>, "as" | "orientation"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                        default?(_: {}): any;
+                        default?(_: {}): any;
+                        default?(_: {}): any;
+                    };
+                }) | null;
+                horizontal: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        as: import('radix-vue').AsTag | import('vue').Component;
+                        orientation: "vertical" | "horizontal";
+                    }> & Omit<{
+                        readonly as: import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component;
+                        readonly orientation: "vertical" | "horizontal";
+                        readonly forceMount?: boolean | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "as" | "orientation">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                            default: string;
+                        };
+                        forceMount: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        orientation: {
+                            type: import('vue').PropType<"horizontal" | "vertical">;
+                            default: string;
+                        };
+                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        as: import('radix-vue').AsTag | import('vue').Component;
+                        orientation: "vertical" | "horizontal";
+                    }, {}, 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 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<{
+                    as: import('radix-vue').AsTag | import('vue').Component;
+                    orientation: "vertical" | "horizontal";
+                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        default: string;
+                    };
+                    forceMount: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    orientation: {
+                        type: import('vue').PropType<"horizontal" | "vertical">;
+                        default: string;
+                    };
+                }>>, "as" | "orientation"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                        default?(_: {}): any;
+                        default?(_: {}): any;
+                        default?(_: {}): any;
+                    };
+                }) | null;
+                corner: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{
+                        readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        };
+                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                    };
+                }) | null;
             };
             $slots: Readonly<{
                 [name: string]: import('vue').Slot<any> | undefined;
@@ -68,8 +489,179 @@ declare function __VLS_template(): {
             $options: import('vue').ComponentOptionsBase<Readonly<import('../ScrollContainer/ScrollContainer').ScrollContainerProps> & Readonly<{
                 onLoadMore?: ((...args: any[]) => any) | undefined;
             }>, {
-                container: import('vue').Ref<any, any>;
-                root: import('vue').Ref<any, any>;
+                container: Readonly<import('vue').ShallowRef<({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{
+                        readonly nonce?: string | undefined;
+                        readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        nonce: {
+                            type: import('vue').PropType<string>;
+                        };
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        };
+                    }>>, {
+                        viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                        beforeCreate?: (() => void) | (() => void)[];
+                        created?: (() => void) | (() => void)[];
+                        beforeMount?: (() => void) | (() => void)[];
+                        mounted?: (() => void) | (() => void)[];
+                        beforeUpdate?: (() => void) | (() => void)[];
+                        updated?: (() => void) | (() => void)[];
+                        activated?: (() => void) | (() => void)[];
+                        deactivated?: (() => void) | (() => void)[];
+                        beforeDestroy?: (() => void) | (() => void)[];
+                        beforeUnmount?: (() => void) | (() => void)[];
+                        destroyed?: (() => void) | (() => void)[];
+                        unmounted?: (() => void) | (() => void)[];
+                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    nonce: {
+                        type: import('vue').PropType<string>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+                    viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                    };
+                }) | null>>;
+                root: Readonly<import('vue').ShallowRef<({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                        scrollHideDelay: number;
+                    }> & Omit<{
+                        readonly type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                        readonly scrollHideDelay: number;
+                        readonly dir?: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction | undefined;
+                        readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                        readonly asChild?: boolean | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "scrollHideDelay">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any> | undefined;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                        dir: {
+                            type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                        };
+                        type: {
+                            type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                            default: string;
+                        };
+                        as: {
+                            type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        };
+                        asChild: {
+                            type: import('vue').PropType<boolean>;
+                        };
+                        scrollHideDelay: {
+                            type: import('vue').PropType<number>;
+                            default: number;
+                        };
+                    }>>, {
+                        viewport: import('vue').Ref<HTMLElement | undefined>;
+                        scrollTop: () => void;
+                        scrollTopLeft: () => void;
+                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                        scrollHideDelay: 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 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('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: number;
+                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    dir: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                    };
+                    type: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                        default: string;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    scrollHideDelay: {
+                        type: import('vue').PropType<number>;
+                        default: number;
+                    };
+                }>>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+                    viewport: import('vue').Ref<HTMLElement | undefined>;
+                    scrollTop: () => void;
+                    scrollTopLeft: () => void;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: {
+                        default?(_: {}): any;
+                    };
+                }) | null>>;
             }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                 loadMore: (...args: any[]) => void;
             }, string, {
@@ -106,9 +698,180 @@ declare function __VLS_template(): {
             overlay: boolean;
         }> & Omit<Readonly<import('../ScrollContainer/ScrollContainer').ScrollContainerProps> & Readonly<{
             onLoadMore?: ((...args: any[]) => any) | undefined;
-        }>, "root" | "container" | ("type" | "size" | "scrollDistance" | "scrollHideDelay" | "overlay")> & import('vue').ShallowUnwrapRef<{
-            container: import('vue').Ref<any, any>;
-            root: import('vue').Ref<any, any>;
+        }>, "root" | ("type" | "size" | "scrollDistance" | "scrollHideDelay" | "overlay") | "container"> & import('vue').ShallowUnwrapRef<{
+            container: Readonly<import('vue').ShallowRef<({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{
+                    readonly nonce?: string | undefined;
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    nonce: {
+                        type: import('vue').PropType<string>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, {
+                    viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                nonce: {
+                    type: import('vue').PropType<string>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+            }>>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+                viewportElement: import('vue').Ref<HTMLElement | undefined>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null>>;
+            root: Readonly<import('vue').ShallowRef<({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: number;
+                }> & Omit<{
+                    readonly type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    readonly scrollHideDelay: number;
+                    readonly dir?: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction | undefined;
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "scrollHideDelay">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    dir: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                    };
+                    type: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                        default: string;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    scrollHideDelay: {
+                        type: import('vue').PropType<number>;
+                        default: number;
+                    };
+                }>>, {
+                    viewport: import('vue').Ref<HTMLElement | undefined>;
+                    scrollTop: () => void;
+                    scrollTopLeft: () => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: 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 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('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                scrollHideDelay: number;
+            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                dir: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                };
+                type: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                    default: string;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                scrollHideDelay: {
+                    type: import('vue').PropType<number>;
+                    default: number;
+                };
+            }>>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+                viewport: import('vue').Ref<HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null>>;
         }> & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
                 default?(_: {}): any;
@@ -116,13 +879,14 @@ declare function __VLS_template(): {
             };
         }) | null;
         textarea: HTMLTextAreaElement;
+        textHeight: HTMLDivElement;
     };
     attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<TextareaProps, {
     textarea: Readonly<import('vue').ShallowRef<HTMLTextAreaElement | null>>;
-    focus: (option?: FocusOptions) => void | undefined;
+    focus: (opt?: FocusOptions) => void | undefined;
     blur: () => void | undefined;
     select: () => void | undefined;
     setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none") => void | undefined;
@@ -166,6 +930,425 @@ declare const __VLS_component: import('vue').DefineComponent<TextareaProps, {
         };
         $refs: {
             [x: string]: unknown;
+        } & {
+            root: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: number;
+                }> & Omit<{
+                    readonly type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    readonly scrollHideDelay: number;
+                    readonly dir?: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction | undefined;
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "scrollHideDelay">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    dir: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                    };
+                    type: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                        default: string;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    scrollHideDelay: {
+                        type: import('vue').PropType<number>;
+                        default: number;
+                    };
+                }>>, {
+                    viewport: import('vue').Ref<HTMLElement | undefined>;
+                    scrollTop: () => void;
+                    scrollTopLeft: () => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: 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 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('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                scrollHideDelay: number;
+            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                dir: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                };
+                type: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                    default: string;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                scrollHideDelay: {
+                    type: import('vue').PropType<number>;
+                    default: number;
+                };
+            }>>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+                viewport: import('vue').Ref<HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null;
+            container: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{
+                    readonly nonce?: string | undefined;
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    nonce: {
+                        type: import('vue').PropType<string>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, {
+                    viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                nonce: {
+                    type: import('vue').PropType<string>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+            }>>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+                viewportElement: import('vue').Ref<HTMLElement | undefined>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null;
+            wrap: HTMLDivElement;
+            top: HTMLDivElement;
+            end: HTMLDivElement;
+            start: HTMLDivElement;
+            bottom: HTMLDivElement;
+            vertical: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    as: import('radix-vue').AsTag | import('vue').Component;
+                    orientation: "vertical" | "horizontal";
+                }> & Omit<{
+                    readonly as: import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component;
+                    readonly orientation: "vertical" | "horizontal";
+                    readonly forceMount?: boolean | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "as" | "orientation">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        default: string;
+                    };
+                    forceMount: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    orientation: {
+                        type: import('vue').PropType<"horizontal" | "vertical">;
+                        default: string;
+                    };
+                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    as: import('radix-vue').AsTag | import('vue').Component;
+                    orientation: "vertical" | "horizontal";
+                }, {}, 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 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<{
+                as: import('radix-vue').AsTag | import('vue').Component;
+                orientation: "vertical" | "horizontal";
+            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    default: string;
+                };
+                forceMount: {
+                    type: import('vue').PropType<boolean>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                orientation: {
+                    type: import('vue').PropType<"horizontal" | "vertical">;
+                    default: string;
+                };
+            }>>, "as" | "orientation"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                    default?(_: {}): any;
+                    default?(_: {}): any;
+                    default?(_: {}): any;
+                };
+            }) | null;
+            horizontal: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    as: import('radix-vue').AsTag | import('vue').Component;
+                    orientation: "vertical" | "horizontal";
+                }> & Omit<{
+                    readonly as: import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component;
+                    readonly orientation: "vertical" | "horizontal";
+                    readonly forceMount?: boolean | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "as" | "orientation">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                        default: string;
+                    };
+                    forceMount: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    orientation: {
+                        type: import('vue').PropType<"horizontal" | "vertical">;
+                        default: string;
+                    };
+                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    as: import('radix-vue').AsTag | import('vue').Component;
+                    orientation: "vertical" | "horizontal";
+                }, {}, 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 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<{
+                as: import('radix-vue').AsTag | import('vue').Component;
+                orientation: "vertical" | "horizontal";
+            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    default: string;
+                };
+                forceMount: {
+                    type: import('vue').PropType<boolean>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                orientation: {
+                    type: import('vue').PropType<"horizontal" | "vertical">;
+                    default: string;
+                };
+            }>>, "as" | "orientation"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                    default?(_: {}): any;
+                    default?(_: {}): any;
+                    default?(_: {}): any;
+                };
+            }) | null;
+            corner: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+            }>>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null;
         };
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
@@ -178,8 +1361,179 @@ declare const __VLS_component: import('vue').DefineComponent<TextareaProps, {
         $options: import('vue').ComponentOptionsBase<Readonly<import('../ScrollContainer/ScrollContainer').ScrollContainerProps> & Readonly<{
             onLoadMore?: ((...args: any[]) => any) | undefined;
         }>, {
-            container: import('vue').Ref<any, any>;
-            root: import('vue').Ref<any, any>;
+            container: Readonly<import('vue').ShallowRef<({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{
+                    readonly nonce?: string | undefined;
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    nonce: {
+                        type: import('vue').PropType<string>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                }>>, {
+                    viewportElement: import('vue').Ref<HTMLElement | undefined>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                nonce: {
+                    type: import('vue').PropType<string>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+            }>>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+                viewportElement: import('vue').Ref<HTMLElement | undefined>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null>>;
+            root: Readonly<import('vue').ShallowRef<({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: number;
+                }> & Omit<{
+                    readonly type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    readonly scrollHideDelay: number;
+                    readonly dir?: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction | undefined;
+                    readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                    readonly asChild?: boolean | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "scrollHideDelay">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    dir: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                    };
+                    type: {
+                        type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                        default: string;
+                    };
+                    as: {
+                        type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                    };
+                    asChild: {
+                        type: import('vue').PropType<boolean>;
+                    };
+                    scrollHideDelay: {
+                        type: import('vue').PropType<number>;
+                        default: number;
+                    };
+                }>>, {
+                    viewport: import('vue').Ref<HTMLElement | undefined>;
+                    scrollTop: () => void;
+                    scrollTopLeft: () => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                    scrollHideDelay: 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 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('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                scrollHideDelay: number;
+            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                dir: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                };
+                type: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                    default: string;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                scrollHideDelay: {
+                    type: import('vue').PropType<number>;
+                    default: number;
+                };
+            }>>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+                viewport: import('vue').Ref<HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?(_: {}): any;
+                };
+            }) | null>>;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
             loadMore: (...args: any[]) => void;
         }, string, {
@@ -216,9 +1570,180 @@ declare const __VLS_component: import('vue').DefineComponent<TextareaProps, {
         overlay: boolean;
     }> & Omit<Readonly<import('../ScrollContainer/ScrollContainer').ScrollContainerProps> & Readonly<{
         onLoadMore?: ((...args: any[]) => any) | undefined;
-    }>, "root" | "container" | ("type" | "size" | "scrollDistance" | "scrollHideDelay" | "overlay")> & import('vue').ShallowUnwrapRef<{
-        container: import('vue').Ref<any, any>;
-        root: import('vue').Ref<any, any>;
+    }>, "root" | ("type" | "size" | "scrollDistance" | "scrollHideDelay" | "overlay") | "container"> & import('vue').ShallowUnwrapRef<{
+        container: Readonly<import('vue').ShallowRef<({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{
+                readonly nonce?: string | undefined;
+                readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                readonly asChild?: boolean | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                nonce: {
+                    type: import('vue').PropType<string>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+            }>>, {
+                viewportElement: import('vue').Ref<HTMLElement | undefined>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof 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<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
+            nonce: {
+                type: import('vue').PropType<string>;
+            };
+            asChild: {
+                type: import('vue').PropType<boolean>;
+            };
+            as: {
+                type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+            };
+        }>>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+            viewportElement: import('vue').Ref<HTMLElement | undefined>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null>>;
+        root: Readonly<import('vue').ShallowRef<({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                scrollHideDelay: number;
+            }> & Omit<{
+                readonly type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                readonly scrollHideDelay: number;
+                readonly dir?: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction | undefined;
+                readonly as?: (import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component) | undefined;
+                readonly asChild?: boolean | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "type" | "scrollHideDelay">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                dir: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+                };
+                type: {
+                    type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                    default: string;
+                };
+                as: {
+                    type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+                };
+                asChild: {
+                    type: import('vue').PropType<boolean>;
+                };
+                scrollHideDelay: {
+                    type: import('vue').PropType<number>;
+                    default: number;
+                };
+            }>>, {
+                viewport: import('vue').Ref<HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                type: import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+                scrollHideDelay: 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 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('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType;
+            scrollHideDelay: number;
+        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+            dir: {
+                type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).Direction>;
+            };
+            type: {
+                type: import('vue').PropType<import('../../../../node_modules/radix-vue/dist/ScrollArea/types.js', { with: { "resolution-mode": "import" } }).ScrollType>;
+                default: string;
+            };
+            as: {
+                type: import('vue').PropType<import('radix-vue', { with: { "resolution-mode": "import" } }).AsTag | import('vue').Component>;
+            };
+            asChild: {
+                type: import('vue').PropType<boolean>;
+            };
+            scrollHideDelay: {
+                type: import('vue').PropType<number>;
+                default: number;
+            };
+        }>>, "type" | "scrollHideDelay" | "viewport" | "scrollTop" | "scrollTopLeft"> & import('vue').ShallowUnwrapRef<{
+            viewport: import('vue').Ref<HTMLElement | undefined>;
+            scrollTop: () => void;
+            scrollTopLeft: () => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null>>;
     }> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             default?(_: {}): any;
@@ -226,6 +1751,7 @@ declare const __VLS_component: import('vue').DefineComponent<TextareaProps, {
         };
     }) | null;
     textarea: HTMLTextAreaElement;
+    textHeight: HTMLDivElement;
 }, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;