npm - @sdata/web-vue - Versions diffs - 3.29.0 → 4.0.0 - Mend

@sdata/web-vue 3.29.0 → 4.0.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 (742) hide show

package/es/list/index.d.ts CHANGED Viewed

@@ -1,13 +1,11 @@
 import type { App } from 'vue';
 import type { SDOptions } from '../_utils/types';
-import _List from './list';
-import _ListItem from './list-item';
 import _ListItemMeta from './list-item-meta.vue';
+import _ListItem from './list-item.vue';
+import _List from './list.vue';
 declare const List: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-        data: {
-            type: import("vue").PropType<any[]>;
-        };
+        data: import("vue").PropType<any[]>;
         size: {
             type: import("vue").PropType<"small" | "medium" | "large">;
             default: string;
@@ -24,19 +22,13 @@ declare const List: {
             type: BooleanConstructor;
             default: boolean;
         };
-        spinProps: {
-            type: import("vue").PropType<import("../index.ts").SpinProps>;
-        };
+        spinProps: import("vue").PropType<import("../index.ts").SpinProps>;
         hoverable: {
             type: BooleanConstructor;
             default: boolean;
         };
-        paginationProps: {
-            type: import("vue").PropType<import("../index.ts").PaginationProps>;
-        };
-        gridProps: {
-            type: ObjectConstructor;
-        };
+        paginationProps: import("vue").PropType<import("../index.ts").PaginationProps>;
+        gridProps: ObjectConstructor;
         maxHeight: {
             type: import("vue").PropType<string | number>;
             default: number;
@@ -45,9 +37,7 @@ declare const List: {
             type: NumberConstructor;
             default: number;
         };
-        virtualListProps: {
-            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").VirtualListProps>;
-        };
+        virtualListProps: import("vue").PropType<import("../_components/virtual-list/interface.ts").VirtualListProps>;
         scrollbar: {
             type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
             default: boolean;
@@ -58,15 +48,861 @@ declare const List: {
         onPageSizeChange?: ((_pageSize: number) => any) | undefined;
         onPageChange?: ((_page: number) => any) | undefined;
     }>, {
-        virtualListRef: import("vue").Ref<any, any>;
-        render: () => import("vue/jsx-runtime").JSX.Element;
-    }, {}, {}, {
-        scrollIntoView(options: import("../_components/virtual-list/interface.ts").ScrollIntoViewOptions): void;
-    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        scroll: () => true;
-        reachBottom: () => true;
-        pageChange: (_page: number) => true;
-        pageSizeChange: (_pageSize: number) => true;
+        virtualListRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }> & Omit<{
+                readonly shift: boolean;
+                readonly scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                readonly enabled: boolean;
+                readonly emitUpdate: boolean;
+                readonly disableTransform: boolean;
+                readonly flowMode: boolean;
+                readonly skipHover: boolean;
+                readonly items: unknown[];
+                readonly keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                readonly direction: "horizontal" | "vertical";
+                readonly listTag: string;
+                readonly itemTag: string;
+                readonly threshold: number;
+                readonly fixedSize: boolean;
+                readonly paddingPosition: "content" | "list";
+                readonly gridItems?: number | undefined;
+                readonly itemSecondarySize?: number | undefined;
+                readonly sizeField?: string | undefined;
+                readonly typeField?: string | undefined;
+                readonly buffer?: number | undefined;
+                readonly prerender?: number | undefined;
+                readonly hiddenPosition?: number | undefined;
+                readonly updateInterval?: number | undefined;
+                readonly height?: string | number | undefined;
+                readonly itemSize?: import("../_components/virtual-list/interface.ts").ItemSizeValue | undefined;
+                readonly minItemSize?: string | number | null | undefined;
+                readonly listClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly itemClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly estimatedSize?: number | undefined;
+                readonly component?: string | Record<string, unknown> | undefined;
+                readonly listAttrs?: Record<string, unknown> | undefined;
+                readonly contentWrapperAttrs?: Record<string, unknown> | undefined;
+                readonly contentAttrs?: Record<string, unknown> | undefined;
+                readonly listStyle?: import("vue").CSSProperties | undefined;
+                readonly cache?: import("virtua").CacheSnapshot | undefined;
+                readonly onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                readonly onScroll?: ((_ev: Event) => any) | undefined;
+                readonly onHidden?: (() => any) | undefined;
+                readonly onVisible?: (() => any) | undefined;
+                readonly onResize?: (() => any) | undefined;
+                readonly onReachBottom?: ((_ev: Event) => any) | undefined;
+                readonly onScrollStart?: (() => any) | undefined;
+                readonly onScrollEnd?: (() => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "update", _startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => void) & ((event: "scroll", _ev: Event) => void) & ((event: "hidden") => void) & ((event: "visible") => void) & ((event: "resize") => void) & ((event: "reachBottom", _ev: Event) => void) & ((event: "scrollStart") => void) & ((event: "scrollEnd") => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                items: {
+                    type: import("vue").PropType<unknown[]>;
+                    default: () => never[];
+                };
+                height: {
+                    type: import("vue").PropType<number | string>;
+                    default: undefined;
+                };
+                keyField: {
+                    type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                    default: string;
+                };
+                direction: {
+                    type: import("vue").PropType<"vertical" | "horizontal">;
+                    default: string;
+                };
+                listTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemSize: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                    default: undefined;
+                };
+                gridItems: NumberConstructor;
+                itemSecondarySize: NumberConstructor;
+                minItemSize: {
+                    type: import("vue").PropType<number | string | null>;
+                    default: undefined;
+                };
+                sizeField: StringConstructor;
+                typeField: StringConstructor;
+                buffer: NumberConstructor;
+                shift: BooleanConstructor;
+                cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+                prerender: NumberConstructor;
+                emitUpdate: BooleanConstructor;
+                disableTransform: BooleanConstructor;
+                flowMode: BooleanConstructor;
+                hiddenPosition: NumberConstructor;
+                updateInterval: NumberConstructor;
+                skipHover: BooleanConstructor;
+                enabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                listClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                itemClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                threshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                fixedSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                estimatedSize: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+                component: {
+                    type: import("vue").PropType<string | Record<string, unknown>>;
+                    default: undefined;
+                };
+                listAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentWrapperAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                listStyle: {
+                    type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                    default: undefined;
+                };
+                paddingPosition: {
+                    type: import("vue").PropType<"content" | "list">;
+                    default: string;
+                };
+                scrollbar: {
+                    type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                onScroll?: ((_ev: Event) => any) | undefined;
+                onHidden?: (() => any) | undefined;
+                onVisible?: (() => any) | undefined;
+                onResize?: (() => any) | undefined;
+                onReachBottom?: ((_ev: Event) => any) | undefined;
+                onScrollStart?: (() => any) | undefined;
+                onScrollEnd?: (() => any) | undefined;
+            }>, {
+                scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                findItemIndex: (offset: number) => number;
+                getItemOffset: (index: number) => number;
+                getItemSize: (index: number) => number;
+                cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+                restoreCache: () => boolean;
+                updateVisibleItems: () => void;
+                scrollToBottom: () => void;
+                forceUpdate: () => void;
+                getDynamicItemSize: (_item: unknown, index?: number) => number;
+                scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+                scroll: (_ev: Event) => any;
+                hidden: () => any;
+                visible: () => any;
+                resize: () => any;
+                reachBottom: (_ev: Event) => any;
+                scrollStart: () => any;
+                scrollEnd: () => any;
+            }, string, {
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            items: {
+                type: import("vue").PropType<unknown[]>;
+                default: () => never[];
+            };
+            height: {
+                type: import("vue").PropType<number | string>;
+                default: undefined;
+            };
+            keyField: {
+                type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                default: string;
+            };
+            direction: {
+                type: import("vue").PropType<"vertical" | "horizontal">;
+                default: string;
+            };
+            listTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemSize: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                default: undefined;
+            };
+            gridItems: NumberConstructor;
+            itemSecondarySize: NumberConstructor;
+            minItemSize: {
+                type: import("vue").PropType<number | string | null>;
+                default: undefined;
+            };
+            sizeField: StringConstructor;
+            typeField: StringConstructor;
+            buffer: NumberConstructor;
+            shift: BooleanConstructor;
+            cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+            prerender: NumberConstructor;
+            emitUpdate: BooleanConstructor;
+            disableTransform: BooleanConstructor;
+            flowMode: BooleanConstructor;
+            hiddenPosition: NumberConstructor;
+            updateInterval: NumberConstructor;
+            skipHover: BooleanConstructor;
+            enabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            listClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            itemClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            threshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            fixedSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            estimatedSize: {
+                type: NumberConstructor;
+                default: undefined;
+            };
+            component: {
+                type: import("vue").PropType<string | Record<string, unknown>>;
+                default: undefined;
+            };
+            listAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentWrapperAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            listStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                default: undefined;
+            };
+            paddingPosition: {
+                type: import("vue").PropType<"content" | "list">;
+                default: string;
+            };
+            scrollbar: {
+                type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            onScroll?: ((_ev: Event) => any) | undefined;
+            onHidden?: (() => any) | undefined;
+            onVisible?: (() => any) | undefined;
+            onResize?: (() => any) | undefined;
+            onReachBottom?: ((_ev: Event) => any) | undefined;
+            onScrollStart?: (() => any) | undefined;
+            onScrollEnd?: (() => any) | undefined;
+        }>, "scrollTo" | "scrollToItem" | "scrollToPosition" | "findItemIndex" | "getItemOffset" | "getItemSize" | "cacheSnapshot" | "restoreCache" | "updateVisibleItems" | "scrollToBottom" | "forceUpdate" | "getDynamicItemSize" | ("shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition")> & {
+            scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            findItemIndex: (offset: number) => number;
+            getItemOffset: (index: number) => number;
+            getItemSize: (index: number) => number;
+            cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+            restoreCache: () => boolean;
+            updateVisibleItems: () => void;
+            scrollToBottom: () => void;
+            forceUpdate: () => void;
+            getDynamicItemSize: (_item: unknown, index?: number) => number;
+            scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                before?: (props: {}) => any;
+            } & {
+                item?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                default?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                after?: (props: {}) => any;
+            } & {
+                empty?: (props: {}) => any;
+            };
+        }) | undefined, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }> & Omit<{
+                readonly shift: boolean;
+                readonly scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                readonly enabled: boolean;
+                readonly emitUpdate: boolean;
+                readonly disableTransform: boolean;
+                readonly flowMode: boolean;
+                readonly skipHover: boolean;
+                readonly items: unknown[];
+                readonly keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                readonly direction: "horizontal" | "vertical";
+                readonly listTag: string;
+                readonly itemTag: string;
+                readonly threshold: number;
+                readonly fixedSize: boolean;
+                readonly paddingPosition: "content" | "list";
+                readonly gridItems?: number | undefined;
+                readonly itemSecondarySize?: number | undefined;
+                readonly sizeField?: string | undefined;
+                readonly typeField?: string | undefined;
+                readonly buffer?: number | undefined;
+                readonly prerender?: number | undefined;
+                readonly hiddenPosition?: number | undefined;
+                readonly updateInterval?: number | undefined;
+                readonly height?: string | number | undefined;
+                readonly itemSize?: import("../_components/virtual-list/interface.ts").ItemSizeValue | undefined;
+                readonly minItemSize?: string | number | null | undefined;
+                readonly listClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly itemClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly estimatedSize?: number | undefined;
+                readonly component?: string | Record<string, unknown> | undefined;
+                readonly listAttrs?: Record<string, unknown> | undefined;
+                readonly contentWrapperAttrs?: Record<string, unknown> | undefined;
+                readonly contentAttrs?: Record<string, unknown> | undefined;
+                readonly listStyle?: import("vue").CSSProperties | undefined;
+                readonly cache?: import("virtua").CacheSnapshot | undefined;
+                readonly onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                readonly onScroll?: ((_ev: Event) => any) | undefined;
+                readonly onHidden?: (() => any) | undefined;
+                readonly onVisible?: (() => any) | undefined;
+                readonly onResize?: (() => any) | undefined;
+                readonly onReachBottom?: ((_ev: Event) => any) | undefined;
+                readonly onScrollStart?: (() => any) | undefined;
+                readonly onScrollEnd?: (() => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "update", _startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => void) & ((event: "scroll", _ev: Event) => void) & ((event: "hidden") => void) & ((event: "visible") => void) & ((event: "resize") => void) & ((event: "reachBottom", _ev: Event) => void) & ((event: "scrollStart") => void) & ((event: "scrollEnd") => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                items: {
+                    type: import("vue").PropType<unknown[]>;
+                    default: () => never[];
+                };
+                height: {
+                    type: import("vue").PropType<number | string>;
+                    default: undefined;
+                };
+                keyField: {
+                    type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                    default: string;
+                };
+                direction: {
+                    type: import("vue").PropType<"vertical" | "horizontal">;
+                    default: string;
+                };
+                listTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemSize: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                    default: undefined;
+                };
+                gridItems: NumberConstructor;
+                itemSecondarySize: NumberConstructor;
+                minItemSize: {
+                    type: import("vue").PropType<number | string | null>;
+                    default: undefined;
+                };
+                sizeField: StringConstructor;
+                typeField: StringConstructor;
+                buffer: NumberConstructor;
+                shift: BooleanConstructor;
+                cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+                prerender: NumberConstructor;
+                emitUpdate: BooleanConstructor;
+                disableTransform: BooleanConstructor;
+                flowMode: BooleanConstructor;
+                hiddenPosition: NumberConstructor;
+                updateInterval: NumberConstructor;
+                skipHover: BooleanConstructor;
+                enabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                listClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                itemClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                threshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                fixedSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                estimatedSize: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+                component: {
+                    type: import("vue").PropType<string | Record<string, unknown>>;
+                    default: undefined;
+                };
+                listAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentWrapperAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                listStyle: {
+                    type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                    default: undefined;
+                };
+                paddingPosition: {
+                    type: import("vue").PropType<"content" | "list">;
+                    default: string;
+                };
+                scrollbar: {
+                    type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                onScroll?: ((_ev: Event) => any) | undefined;
+                onHidden?: (() => any) | undefined;
+                onVisible?: (() => any) | undefined;
+                onResize?: (() => any) | undefined;
+                onReachBottom?: ((_ev: Event) => any) | undefined;
+                onScrollStart?: (() => any) | undefined;
+                onScrollEnd?: (() => any) | undefined;
+            }>, {
+                scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                findItemIndex: (offset: number) => number;
+                getItemOffset: (index: number) => number;
+                getItemSize: (index: number) => number;
+                cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+                restoreCache: () => boolean;
+                updateVisibleItems: () => void;
+                scrollToBottom: () => void;
+                forceUpdate: () => void;
+                getDynamicItemSize: (_item: unknown, index?: number) => number;
+                scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+                scroll: (_ev: Event) => any;
+                hidden: () => any;
+                visible: () => any;
+                resize: () => any;
+                reachBottom: (_ev: Event) => any;
+                scrollStart: () => any;
+                scrollEnd: () => any;
+            }, string, {
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            items: {
+                type: import("vue").PropType<unknown[]>;
+                default: () => never[];
+            };
+            height: {
+                type: import("vue").PropType<number | string>;
+                default: undefined;
+            };
+            keyField: {
+                type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                default: string;
+            };
+            direction: {
+                type: import("vue").PropType<"vertical" | "horizontal">;
+                default: string;
+            };
+            listTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemSize: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                default: undefined;
+            };
+            gridItems: NumberConstructor;
+            itemSecondarySize: NumberConstructor;
+            minItemSize: {
+                type: import("vue").PropType<number | string | null>;
+                default: undefined;
+            };
+            sizeField: StringConstructor;
+            typeField: StringConstructor;
+            buffer: NumberConstructor;
+            shift: BooleanConstructor;
+            cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+            prerender: NumberConstructor;
+            emitUpdate: BooleanConstructor;
+            disableTransform: BooleanConstructor;
+            flowMode: BooleanConstructor;
+            hiddenPosition: NumberConstructor;
+            updateInterval: NumberConstructor;
+            skipHover: BooleanConstructor;
+            enabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            listClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            itemClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            threshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            fixedSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            estimatedSize: {
+                type: NumberConstructor;
+                default: undefined;
+            };
+            component: {
+                type: import("vue").PropType<string | Record<string, unknown>>;
+                default: undefined;
+            };
+            listAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentWrapperAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            listStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                default: undefined;
+            };
+            paddingPosition: {
+                type: import("vue").PropType<"content" | "list">;
+                default: string;
+            };
+            scrollbar: {
+                type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            onScroll?: ((_ev: Event) => any) | undefined;
+            onHidden?: (() => any) | undefined;
+            onVisible?: (() => any) | undefined;
+            onResize?: (() => any) | undefined;
+            onReachBottom?: ((_ev: Event) => any) | undefined;
+            onScrollStart?: (() => any) | undefined;
+            onScrollEnd?: (() => any) | undefined;
+        }>, "scrollTo" | "scrollToItem" | "scrollToPosition" | "findItemIndex" | "getItemOffset" | "getItemSize" | "cacheSnapshot" | "restoreCache" | "updateVisibleItems" | "scrollToBottom" | "forceUpdate" | "getDynamicItemSize" | ("shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition")> & {
+            scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            findItemIndex: (offset: number) => number;
+            getItemOffset: (index: number) => number;
+            getItemSize: (index: number) => number;
+            cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+            restoreCache: () => boolean;
+            updateVisibleItems: () => void;
+            scrollToBottom: () => void;
+            forceUpdate: () => void;
+            getDynamicItemSize: (_item: unknown, index?: number) => number;
+            scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                before?: (props: {}) => any;
+            } & {
+                item?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                default?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                after?: (props: {}) => any;
+            } & {
+                empty?: (props: {}) => any;
+            };
+        }) | undefined>;
+        scrollIntoView: (options: import("../_components/virtual-list/interface.ts").ScrollIntoViewOptions) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        scroll: () => void;
+        reachBottom: () => void;
+        pageSizeChange: (_pageSize: number) => void;
+        pageChange: (_page: number) => void;
     }, import("vue").PublicProps, {
         split: boolean;
         size: "small" | "medium" | "large";
@@ -84,9 +920,7 @@ declare const List: {
         M: {};
         Defaults: {};
     }, Readonly<import("vue").ExtractPropTypes<{
-        data: {
-            type: import("vue").PropType<any[]>;
-        };
+        data: import("vue").PropType<any[]>;
         size: {
             type: import("vue").PropType<"small" | "medium" | "large">;
             default: string;
@@ -103,19 +937,13 @@ declare const List: {
             type: BooleanConstructor;
             default: boolean;
         };
-        spinProps: {
-            type: import("vue").PropType<import("../index.ts").SpinProps>;
-        };
+        spinProps: import("vue").PropType<import("../index.ts").SpinProps>;
         hoverable: {
             type: BooleanConstructor;
             default: boolean;
         };
-        paginationProps: {
-            type: import("vue").PropType<import("../index.ts").PaginationProps>;
-        };
-        gridProps: {
-            type: ObjectConstructor;
-        };
+        paginationProps: import("vue").PropType<import("../index.ts").PaginationProps>;
+        gridProps: ObjectConstructor;
         maxHeight: {
             type: import("vue").PropType<string | number>;
             default: number;
@@ -124,9 +952,7 @@ declare const List: {
             type: NumberConstructor;
             default: number;
         };
-        virtualListProps: {
-            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").VirtualListProps>;
-        };
+        virtualListProps: import("vue").PropType<import("../_components/virtual-list/interface.ts").VirtualListProps>;
         scrollbar: {
             type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
             default: boolean;
@@ -137,11 +963,857 @@ declare const List: {
         onPageSizeChange?: ((_pageSize: number) => any) | undefined;
         onPageChange?: ((_page: number) => any) | undefined;
     }>, {
-        virtualListRef: import("vue").Ref<any, any>;
-        render: () => import("vue/jsx-runtime").JSX.Element;
-    }, {}, {}, {
-        scrollIntoView(options: import("../_components/virtual-list/interface.ts").ScrollIntoViewOptions): void;
-    }, {
+        virtualListRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }> & Omit<{
+                readonly shift: boolean;
+                readonly scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                readonly enabled: boolean;
+                readonly emitUpdate: boolean;
+                readonly disableTransform: boolean;
+                readonly flowMode: boolean;
+                readonly skipHover: boolean;
+                readonly items: unknown[];
+                readonly keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                readonly direction: "horizontal" | "vertical";
+                readonly listTag: string;
+                readonly itemTag: string;
+                readonly threshold: number;
+                readonly fixedSize: boolean;
+                readonly paddingPosition: "content" | "list";
+                readonly gridItems?: number | undefined;
+                readonly itemSecondarySize?: number | undefined;
+                readonly sizeField?: string | undefined;
+                readonly typeField?: string | undefined;
+                readonly buffer?: number | undefined;
+                readonly prerender?: number | undefined;
+                readonly hiddenPosition?: number | undefined;
+                readonly updateInterval?: number | undefined;
+                readonly height?: string | number | undefined;
+                readonly itemSize?: import("../_components/virtual-list/interface.ts").ItemSizeValue | undefined;
+                readonly minItemSize?: string | number | null | undefined;
+                readonly listClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly itemClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly estimatedSize?: number | undefined;
+                readonly component?: string | Record<string, unknown> | undefined;
+                readonly listAttrs?: Record<string, unknown> | undefined;
+                readonly contentWrapperAttrs?: Record<string, unknown> | undefined;
+                readonly contentAttrs?: Record<string, unknown> | undefined;
+                readonly listStyle?: import("vue").CSSProperties | undefined;
+                readonly cache?: import("virtua").CacheSnapshot | undefined;
+                readonly onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                readonly onScroll?: ((_ev: Event) => any) | undefined;
+                readonly onHidden?: (() => any) | undefined;
+                readonly onVisible?: (() => any) | undefined;
+                readonly onResize?: (() => any) | undefined;
+                readonly onReachBottom?: ((_ev: Event) => any) | undefined;
+                readonly onScrollStart?: (() => any) | undefined;
+                readonly onScrollEnd?: (() => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "update", _startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => void) & ((event: "scroll", _ev: Event) => void) & ((event: "hidden") => void) & ((event: "visible") => void) & ((event: "resize") => void) & ((event: "reachBottom", _ev: Event) => void) & ((event: "scrollStart") => void) & ((event: "scrollEnd") => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                items: {
+                    type: import("vue").PropType<unknown[]>;
+                    default: () => never[];
+                };
+                height: {
+                    type: import("vue").PropType<number | string>;
+                    default: undefined;
+                };
+                keyField: {
+                    type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                    default: string;
+                };
+                direction: {
+                    type: import("vue").PropType<"vertical" | "horizontal">;
+                    default: string;
+                };
+                listTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemSize: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                    default: undefined;
+                };
+                gridItems: NumberConstructor;
+                itemSecondarySize: NumberConstructor;
+                minItemSize: {
+                    type: import("vue").PropType<number | string | null>;
+                    default: undefined;
+                };
+                sizeField: StringConstructor;
+                typeField: StringConstructor;
+                buffer: NumberConstructor;
+                shift: BooleanConstructor;
+                cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+                prerender: NumberConstructor;
+                emitUpdate: BooleanConstructor;
+                disableTransform: BooleanConstructor;
+                flowMode: BooleanConstructor;
+                hiddenPosition: NumberConstructor;
+                updateInterval: NumberConstructor;
+                skipHover: BooleanConstructor;
+                enabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                listClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                itemClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                threshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                fixedSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                estimatedSize: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+                component: {
+                    type: import("vue").PropType<string | Record<string, unknown>>;
+                    default: undefined;
+                };
+                listAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentWrapperAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                listStyle: {
+                    type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                    default: undefined;
+                };
+                paddingPosition: {
+                    type: import("vue").PropType<"content" | "list">;
+                    default: string;
+                };
+                scrollbar: {
+                    type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                onScroll?: ((_ev: Event) => any) | undefined;
+                onHidden?: (() => any) | undefined;
+                onVisible?: (() => any) | undefined;
+                onResize?: (() => any) | undefined;
+                onReachBottom?: ((_ev: Event) => any) | undefined;
+                onScrollStart?: (() => any) | undefined;
+                onScrollEnd?: (() => any) | undefined;
+            }>, {
+                scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                findItemIndex: (offset: number) => number;
+                getItemOffset: (index: number) => number;
+                getItemSize: (index: number) => number;
+                cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+                restoreCache: () => boolean;
+                updateVisibleItems: () => void;
+                scrollToBottom: () => void;
+                forceUpdate: () => void;
+                getDynamicItemSize: (_item: unknown, index?: number) => number;
+                scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+                scroll: (_ev: Event) => any;
+                hidden: () => any;
+                visible: () => any;
+                resize: () => any;
+                reachBottom: (_ev: Event) => any;
+                scrollStart: () => any;
+                scrollEnd: () => any;
+            }, string, {
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            items: {
+                type: import("vue").PropType<unknown[]>;
+                default: () => never[];
+            };
+            height: {
+                type: import("vue").PropType<number | string>;
+                default: undefined;
+            };
+            keyField: {
+                type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                default: string;
+            };
+            direction: {
+                type: import("vue").PropType<"vertical" | "horizontal">;
+                default: string;
+            };
+            listTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemSize: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                default: undefined;
+            };
+            gridItems: NumberConstructor;
+            itemSecondarySize: NumberConstructor;
+            minItemSize: {
+                type: import("vue").PropType<number | string | null>;
+                default: undefined;
+            };
+            sizeField: StringConstructor;
+            typeField: StringConstructor;
+            buffer: NumberConstructor;
+            shift: BooleanConstructor;
+            cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+            prerender: NumberConstructor;
+            emitUpdate: BooleanConstructor;
+            disableTransform: BooleanConstructor;
+            flowMode: BooleanConstructor;
+            hiddenPosition: NumberConstructor;
+            updateInterval: NumberConstructor;
+            skipHover: BooleanConstructor;
+            enabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            listClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            itemClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            threshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            fixedSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            estimatedSize: {
+                type: NumberConstructor;
+                default: undefined;
+            };
+            component: {
+                type: import("vue").PropType<string | Record<string, unknown>>;
+                default: undefined;
+            };
+            listAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentWrapperAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            listStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                default: undefined;
+            };
+            paddingPosition: {
+                type: import("vue").PropType<"content" | "list">;
+                default: string;
+            };
+            scrollbar: {
+                type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            onScroll?: ((_ev: Event) => any) | undefined;
+            onHidden?: (() => any) | undefined;
+            onVisible?: (() => any) | undefined;
+            onResize?: (() => any) | undefined;
+            onReachBottom?: ((_ev: Event) => any) | undefined;
+            onScrollStart?: (() => any) | undefined;
+            onScrollEnd?: (() => any) | undefined;
+        }>, "scrollTo" | "scrollToItem" | "scrollToPosition" | "findItemIndex" | "getItemOffset" | "getItemSize" | "cacheSnapshot" | "restoreCache" | "updateVisibleItems" | "scrollToBottom" | "forceUpdate" | "getDynamicItemSize" | ("shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition")> & {
+            scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            findItemIndex: (offset: number) => number;
+            getItemOffset: (index: number) => number;
+            getItemSize: (index: number) => number;
+            cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+            restoreCache: () => boolean;
+            updateVisibleItems: () => void;
+            scrollToBottom: () => void;
+            forceUpdate: () => void;
+            getDynamicItemSize: (_item: unknown, index?: number) => number;
+            scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                before?: (props: {}) => any;
+            } & {
+                item?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                default?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                after?: (props: {}) => any;
+            } & {
+                empty?: (props: {}) => any;
+            };
+        }) | undefined, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }> & Omit<{
+                readonly shift: boolean;
+                readonly scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                readonly enabled: boolean;
+                readonly emitUpdate: boolean;
+                readonly disableTransform: boolean;
+                readonly flowMode: boolean;
+                readonly skipHover: boolean;
+                readonly items: unknown[];
+                readonly keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                readonly direction: "horizontal" | "vertical";
+                readonly listTag: string;
+                readonly itemTag: string;
+                readonly threshold: number;
+                readonly fixedSize: boolean;
+                readonly paddingPosition: "content" | "list";
+                readonly gridItems?: number | undefined;
+                readonly itemSecondarySize?: number | undefined;
+                readonly sizeField?: string | undefined;
+                readonly typeField?: string | undefined;
+                readonly buffer?: number | undefined;
+                readonly prerender?: number | undefined;
+                readonly hiddenPosition?: number | undefined;
+                readonly updateInterval?: number | undefined;
+                readonly height?: string | number | undefined;
+                readonly itemSize?: import("../_components/virtual-list/interface.ts").ItemSizeValue | undefined;
+                readonly minItemSize?: string | number | null | undefined;
+                readonly listClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly itemClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+                readonly estimatedSize?: number | undefined;
+                readonly component?: string | Record<string, unknown> | undefined;
+                readonly listAttrs?: Record<string, unknown> | undefined;
+                readonly contentWrapperAttrs?: Record<string, unknown> | undefined;
+                readonly contentAttrs?: Record<string, unknown> | undefined;
+                readonly listStyle?: import("vue").CSSProperties | undefined;
+                readonly cache?: import("virtua").CacheSnapshot | undefined;
+                readonly onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                readonly onScroll?: ((_ev: Event) => any) | undefined;
+                readonly onHidden?: (() => any) | undefined;
+                readonly onVisible?: (() => any) | undefined;
+                readonly onResize?: (() => any) | undefined;
+                readonly onReachBottom?: ((_ev: Event) => any) | undefined;
+                readonly onScrollStart?: (() => any) | undefined;
+                readonly onScrollEnd?: (() => any) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition">;
+            $attrs: import("vue").Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "update", _startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => void) & ((event: "scroll", _ev: Event) => void) & ((event: "hidden") => void) & ((event: "visible") => void) & ((event: "resize") => void) & ((event: "reachBottom", _ev: Event) => void) & ((event: "scrollStart") => void) & ((event: "scrollEnd") => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                items: {
+                    type: import("vue").PropType<unknown[]>;
+                    default: () => never[];
+                };
+                height: {
+                    type: import("vue").PropType<number | string>;
+                    default: undefined;
+                };
+                keyField: {
+                    type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                    default: string;
+                };
+                direction: {
+                    type: import("vue").PropType<"vertical" | "horizontal">;
+                    default: string;
+                };
+                listTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemTag: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                itemSize: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                    default: undefined;
+                };
+                gridItems: NumberConstructor;
+                itemSecondarySize: NumberConstructor;
+                minItemSize: {
+                    type: import("vue").PropType<number | string | null>;
+                    default: undefined;
+                };
+                sizeField: StringConstructor;
+                typeField: StringConstructor;
+                buffer: NumberConstructor;
+                shift: BooleanConstructor;
+                cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+                prerender: NumberConstructor;
+                emitUpdate: BooleanConstructor;
+                disableTransform: BooleanConstructor;
+                flowMode: BooleanConstructor;
+                hiddenPosition: NumberConstructor;
+                updateInterval: NumberConstructor;
+                skipHover: BooleanConstructor;
+                enabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                listClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                itemClass: {
+                    type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+                };
+                threshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                fixedSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                estimatedSize: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+                component: {
+                    type: import("vue").PropType<string | Record<string, unknown>>;
+                    default: undefined;
+                };
+                listAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentWrapperAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                contentAttrs: {
+                    type: import("vue").PropType<Record<string, unknown> | undefined>;
+                    default: undefined;
+                };
+                listStyle: {
+                    type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                    default: undefined;
+                };
+                paddingPosition: {
+                    type: import("vue").PropType<"content" | "list">;
+                    default: string;
+                };
+                scrollbar: {
+                    type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+                onScroll?: ((_ev: Event) => any) | undefined;
+                onHidden?: (() => any) | undefined;
+                onVisible?: (() => any) | undefined;
+                onResize?: (() => any) | undefined;
+                onReachBottom?: ((_ev: Event) => any) | undefined;
+                onScrollStart?: (() => any) | undefined;
+                onScrollEnd?: (() => any) | undefined;
+            }>, {
+                scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+                findItemIndex: (offset: number) => number;
+                getItemOffset: (index: number) => number;
+                getItemSize: (index: number) => number;
+                cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+                restoreCache: () => boolean;
+                updateVisibleItems: () => void;
+                scrollToBottom: () => void;
+                forceUpdate: () => void;
+                getDynamicItemSize: (_item: unknown, index?: number) => number;
+                scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+                scroll: (_ev: Event) => any;
+                hidden: () => any;
+                visible: () => any;
+                resize: () => any;
+                reachBottom: (_ev: Event) => any;
+                scrollStart: () => any;
+                scrollEnd: () => any;
+            }, string, {
+                shift: boolean;
+                scrollbar: boolean | import("../index.ts").ScrollbarProps;
+                enabled: boolean;
+                emitUpdate: boolean;
+                disableTransform: boolean;
+                flowMode: boolean;
+                skipHover: boolean;
+                items: unknown[];
+                height: string | number;
+                keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+                direction: "horizontal" | "vertical";
+                listTag: string;
+                itemTag: string;
+                itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+                minItemSize: string | number | null;
+                threshold: number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                component: string | Record<string, unknown>;
+                listAttrs: Record<string, unknown> | undefined;
+                contentWrapperAttrs: Record<string, unknown> | undefined;
+                contentAttrs: Record<string, unknown> | undefined;
+                listStyle: import("vue").CSSProperties | undefined;
+                paddingPosition: "content" | "list";
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            items: {
+                type: import("vue").PropType<unknown[]>;
+                default: () => never[];
+            };
+            height: {
+                type: import("vue").PropType<number | string>;
+                default: undefined;
+            };
+            keyField: {
+                type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                default: string;
+            };
+            direction: {
+                type: import("vue").PropType<"vertical" | "horizontal">;
+                default: string;
+            };
+            listTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemSize: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                default: undefined;
+            };
+            gridItems: NumberConstructor;
+            itemSecondarySize: NumberConstructor;
+            minItemSize: {
+                type: import("vue").PropType<number | string | null>;
+                default: undefined;
+            };
+            sizeField: StringConstructor;
+            typeField: StringConstructor;
+            buffer: NumberConstructor;
+            shift: BooleanConstructor;
+            cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+            prerender: NumberConstructor;
+            emitUpdate: BooleanConstructor;
+            disableTransform: BooleanConstructor;
+            flowMode: BooleanConstructor;
+            hiddenPosition: NumberConstructor;
+            updateInterval: NumberConstructor;
+            skipHover: BooleanConstructor;
+            enabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            listClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            itemClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            threshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            fixedSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            estimatedSize: {
+                type: NumberConstructor;
+                default: undefined;
+            };
+            component: {
+                type: import("vue").PropType<string | Record<string, unknown>>;
+                default: undefined;
+            };
+            listAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentWrapperAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            listStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                default: undefined;
+            };
+            paddingPosition: {
+                type: import("vue").PropType<"content" | "list">;
+                default: string;
+            };
+            scrollbar: {
+                type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            onScroll?: ((_ev: Event) => any) | undefined;
+            onHidden?: (() => any) | undefined;
+            onVisible?: (() => any) | undefined;
+            onResize?: (() => any) | undefined;
+            onReachBottom?: ((_ev: Event) => any) | undefined;
+            onScrollStart?: (() => any) | undefined;
+            onScrollEnd?: (() => any) | undefined;
+        }>, "scrollTo" | "scrollToItem" | "scrollToPosition" | "findItemIndex" | "getItemOffset" | "getItemSize" | "cacheSnapshot" | "restoreCache" | "updateVisibleItems" | "scrollToBottom" | "forceUpdate" | "getDynamicItemSize" | ("shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition")> & {
+            scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            findItemIndex: (offset: number) => number;
+            getItemOffset: (index: number) => number;
+            getItemSize: (index: number) => number;
+            cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+            restoreCache: () => boolean;
+            updateVisibleItems: () => void;
+            scrollToBottom: () => void;
+            forceUpdate: () => void;
+            getDynamicItemSize: (_item: unknown, index?: number) => number;
+            scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+        } & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                before?: (props: {}) => any;
+            } & {
+                item?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                default?: (props: {
+                    item: any;
+                    index: number;
+                    active: boolean;
+                    itemWithSize: undefined;
+                }) => any;
+            } & {
+                after?: (props: {}) => any;
+            } & {
+                empty?: (props: {}) => any;
+            };
+        }) | undefined>;
+        scrollIntoView: (options: import("../_components/virtual-list/interface.ts").ScrollIntoViewOptions) => void;
+    }, {}, {}, {}, {
         split: boolean;
         size: "small" | "medium" | "large";
         scrollbar: boolean | import("../index.ts").ScrollbarProps;
@@ -155,9 +1827,7 @@ declare const List: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    data: {
-        type: import("vue").PropType<any[]>;
-    };
+    data: import("vue").PropType<any[]>;
     size: {
         type: import("vue").PropType<"small" | "medium" | "large">;
         default: string;
@@ -174,19 +1844,13 @@ declare const List: {
         type: BooleanConstructor;
         default: boolean;
     };
-    spinProps: {
-        type: import("vue").PropType<import("../index.ts").SpinProps>;
-    };
+    spinProps: import("vue").PropType<import("../index.ts").SpinProps>;
     hoverable: {
         type: BooleanConstructor;
         default: boolean;
     };
-    paginationProps: {
-        type: import("vue").PropType<import("../index.ts").PaginationProps>;
-    };
-    gridProps: {
-        type: ObjectConstructor;
-    };
+    paginationProps: import("vue").PropType<import("../index.ts").PaginationProps>;
+    gridProps: ObjectConstructor;
     maxHeight: {
         type: import("vue").PropType<string | number>;
         default: number;
@@ -195,9 +1859,7 @@ declare const List: {
         type: NumberConstructor;
         default: number;
     };
-    virtualListProps: {
-        type: import("vue").PropType<import("../_components/virtual-list/interface.ts").VirtualListProps>;
-    };
+    virtualListProps: import("vue").PropType<import("../_components/virtual-list/interface.ts").VirtualListProps>;
     scrollbar: {
         type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
         default: boolean;
@@ -208,15 +1870,861 @@ declare const List: {
     onPageSizeChange?: ((_pageSize: number) => any) | undefined;
     onPageChange?: ((_page: number) => any) | undefined;
 }>, {
-    virtualListRef: import("vue").Ref<any, any>;
-    render: () => import("vue/jsx-runtime").JSX.Element;
-}, {}, {}, {
-    scrollIntoView(options: import("../_components/virtual-list/interface.ts").ScrollIntoViewOptions): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    scroll: () => true;
-    reachBottom: () => true;
-    pageChange: (_page: number) => true;
-    pageSizeChange: (_pageSize: number) => true;
+    virtualListRef: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }> & Omit<{
+            readonly shift: boolean;
+            readonly scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            readonly enabled: boolean;
+            readonly emitUpdate: boolean;
+            readonly disableTransform: boolean;
+            readonly flowMode: boolean;
+            readonly skipHover: boolean;
+            readonly items: unknown[];
+            readonly keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            readonly direction: "horizontal" | "vertical";
+            readonly listTag: string;
+            readonly itemTag: string;
+            readonly threshold: number;
+            readonly fixedSize: boolean;
+            readonly paddingPosition: "content" | "list";
+            readonly gridItems?: number | undefined;
+            readonly itemSecondarySize?: number | undefined;
+            readonly sizeField?: string | undefined;
+            readonly typeField?: string | undefined;
+            readonly buffer?: number | undefined;
+            readonly prerender?: number | undefined;
+            readonly hiddenPosition?: number | undefined;
+            readonly updateInterval?: number | undefined;
+            readonly height?: string | number | undefined;
+            readonly itemSize?: import("../_components/virtual-list/interface.ts").ItemSizeValue | undefined;
+            readonly minItemSize?: string | number | null | undefined;
+            readonly listClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+            readonly itemClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+            readonly estimatedSize?: number | undefined;
+            readonly component?: string | Record<string, unknown> | undefined;
+            readonly listAttrs?: Record<string, unknown> | undefined;
+            readonly contentWrapperAttrs?: Record<string, unknown> | undefined;
+            readonly contentAttrs?: Record<string, unknown> | undefined;
+            readonly listStyle?: import("vue").CSSProperties | undefined;
+            readonly cache?: import("virtua").CacheSnapshot | undefined;
+            readonly onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            readonly onScroll?: ((_ev: Event) => any) | undefined;
+            readonly onHidden?: (() => any) | undefined;
+            readonly onVisible?: (() => any) | undefined;
+            readonly onResize?: (() => any) | undefined;
+            readonly onReachBottom?: ((_ev: Event) => any) | undefined;
+            readonly onScrollStart?: (() => any) | undefined;
+            readonly onScrollEnd?: (() => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update", _startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => void) & ((event: "scroll", _ev: Event) => void) & ((event: "hidden") => void) & ((event: "visible") => void) & ((event: "resize") => void) & ((event: "reachBottom", _ev: Event) => void) & ((event: "scrollStart") => void) & ((event: "scrollEnd") => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            items: {
+                type: import("vue").PropType<unknown[]>;
+                default: () => never[];
+            };
+            height: {
+                type: import("vue").PropType<number | string>;
+                default: undefined;
+            };
+            keyField: {
+                type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                default: string;
+            };
+            direction: {
+                type: import("vue").PropType<"vertical" | "horizontal">;
+                default: string;
+            };
+            listTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemSize: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                default: undefined;
+            };
+            gridItems: NumberConstructor;
+            itemSecondarySize: NumberConstructor;
+            minItemSize: {
+                type: import("vue").PropType<number | string | null>;
+                default: undefined;
+            };
+            sizeField: StringConstructor;
+            typeField: StringConstructor;
+            buffer: NumberConstructor;
+            shift: BooleanConstructor;
+            cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+            prerender: NumberConstructor;
+            emitUpdate: BooleanConstructor;
+            disableTransform: BooleanConstructor;
+            flowMode: BooleanConstructor;
+            hiddenPosition: NumberConstructor;
+            updateInterval: NumberConstructor;
+            skipHover: BooleanConstructor;
+            enabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            listClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            itemClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            threshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            fixedSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            estimatedSize: {
+                type: NumberConstructor;
+                default: undefined;
+            };
+            component: {
+                type: import("vue").PropType<string | Record<string, unknown>>;
+                default: undefined;
+            };
+            listAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentWrapperAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            listStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                default: undefined;
+            };
+            paddingPosition: {
+                type: import("vue").PropType<"content" | "list">;
+                default: string;
+            };
+            scrollbar: {
+                type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            onScroll?: ((_ev: Event) => any) | undefined;
+            onHidden?: (() => any) | undefined;
+            onVisible?: (() => any) | undefined;
+            onResize?: (() => any) | undefined;
+            onReachBottom?: ((_ev: Event) => any) | undefined;
+            onScrollStart?: (() => any) | undefined;
+            onScrollEnd?: (() => any) | undefined;
+        }>, {
+            scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            findItemIndex: (offset: number) => number;
+            getItemOffset: (index: number) => number;
+            getItemSize: (index: number) => number;
+            cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+            restoreCache: () => boolean;
+            updateVisibleItems: () => void;
+            scrollToBottom: () => void;
+            forceUpdate: () => void;
+            getDynamicItemSize: (_item: unknown, index?: number) => number;
+            scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+            scroll: (_ev: Event) => any;
+            hidden: () => any;
+            visible: () => any;
+            resize: () => any;
+            reachBottom: (_ev: Event) => any;
+            scrollStart: () => any;
+            scrollEnd: () => any;
+        }, string, {
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        shift: boolean;
+        scrollbar: boolean | import("../index.ts").ScrollbarProps;
+        enabled: boolean;
+        emitUpdate: boolean;
+        disableTransform: boolean;
+        flowMode: boolean;
+        skipHover: boolean;
+        items: unknown[];
+        height: string | number;
+        keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+        direction: "horizontal" | "vertical";
+        listTag: string;
+        itemTag: string;
+        itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+        minItemSize: string | number | null;
+        threshold: number;
+        fixedSize: boolean;
+        estimatedSize: number;
+        component: string | Record<string, unknown>;
+        listAttrs: Record<string, unknown> | undefined;
+        contentWrapperAttrs: Record<string, unknown> | undefined;
+        contentAttrs: Record<string, unknown> | undefined;
+        listStyle: import("vue").CSSProperties | undefined;
+        paddingPosition: "content" | "list";
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        items: {
+            type: import("vue").PropType<unknown[]>;
+            default: () => never[];
+        };
+        height: {
+            type: import("vue").PropType<number | string>;
+            default: undefined;
+        };
+        keyField: {
+            type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+            default: string;
+        };
+        direction: {
+            type: import("vue").PropType<"vertical" | "horizontal">;
+            default: string;
+        };
+        listTag: {
+            type: StringConstructor;
+            default: string;
+        };
+        itemTag: {
+            type: StringConstructor;
+            default: string;
+        };
+        itemSize: {
+            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+            default: undefined;
+        };
+        gridItems: NumberConstructor;
+        itemSecondarySize: NumberConstructor;
+        minItemSize: {
+            type: import("vue").PropType<number | string | null>;
+            default: undefined;
+        };
+        sizeField: StringConstructor;
+        typeField: StringConstructor;
+        buffer: NumberConstructor;
+        shift: BooleanConstructor;
+        cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+        prerender: NumberConstructor;
+        emitUpdate: BooleanConstructor;
+        disableTransform: BooleanConstructor;
+        flowMode: BooleanConstructor;
+        hiddenPosition: NumberConstructor;
+        updateInterval: NumberConstructor;
+        skipHover: BooleanConstructor;
+        enabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        listClass: {
+            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+        };
+        itemClass: {
+            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+        };
+        threshold: {
+            type: NumberConstructor;
+            default: number;
+        };
+        fixedSize: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        estimatedSize: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        component: {
+            type: import("vue").PropType<string | Record<string, unknown>>;
+            default: undefined;
+        };
+        listAttrs: {
+            type: import("vue").PropType<Record<string, unknown> | undefined>;
+            default: undefined;
+        };
+        contentWrapperAttrs: {
+            type: import("vue").PropType<Record<string, unknown> | undefined>;
+            default: undefined;
+        };
+        contentAttrs: {
+            type: import("vue").PropType<Record<string, unknown> | undefined>;
+            default: undefined;
+        };
+        listStyle: {
+            type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+            default: undefined;
+        };
+        paddingPosition: {
+            type: import("vue").PropType<"content" | "list">;
+            default: string;
+        };
+        scrollbar: {
+            type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+        onScroll?: ((_ev: Event) => any) | undefined;
+        onHidden?: (() => any) | undefined;
+        onVisible?: (() => any) | undefined;
+        onResize?: (() => any) | undefined;
+        onReachBottom?: ((_ev: Event) => any) | undefined;
+        onScrollStart?: (() => any) | undefined;
+        onScrollEnd?: (() => any) | undefined;
+    }>, "scrollTo" | "scrollToItem" | "scrollToPosition" | "findItemIndex" | "getItemOffset" | "getItemSize" | "cacheSnapshot" | "restoreCache" | "updateVisibleItems" | "scrollToBottom" | "forceUpdate" | "getDynamicItemSize" | ("shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition")> & {
+        scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+        scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+        findItemIndex: (offset: number) => number;
+        getItemOffset: (index: number) => number;
+        getItemSize: (index: number) => number;
+        cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+        restoreCache: () => boolean;
+        updateVisibleItems: () => void;
+        scrollToBottom: () => void;
+        forceUpdate: () => void;
+        getDynamicItemSize: (_item: unknown, index?: number) => number;
+        scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            before?: (props: {}) => any;
+        } & {
+            item?: (props: {
+                item: any;
+                index: number;
+                active: boolean;
+                itemWithSize: undefined;
+            }) => any;
+        } & {
+            default?: (props: {
+                item: any;
+                index: number;
+                active: boolean;
+                itemWithSize: undefined;
+            }) => any;
+        } & {
+            after?: (props: {}) => any;
+        } & {
+            empty?: (props: {}) => any;
+        };
+    }) | undefined, ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }> & Omit<{
+            readonly shift: boolean;
+            readonly scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            readonly enabled: boolean;
+            readonly emitUpdate: boolean;
+            readonly disableTransform: boolean;
+            readonly flowMode: boolean;
+            readonly skipHover: boolean;
+            readonly items: unknown[];
+            readonly keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            readonly direction: "horizontal" | "vertical";
+            readonly listTag: string;
+            readonly itemTag: string;
+            readonly threshold: number;
+            readonly fixedSize: boolean;
+            readonly paddingPosition: "content" | "list";
+            readonly gridItems?: number | undefined;
+            readonly itemSecondarySize?: number | undefined;
+            readonly sizeField?: string | undefined;
+            readonly typeField?: string | undefined;
+            readonly buffer?: number | undefined;
+            readonly prerender?: number | undefined;
+            readonly hiddenPosition?: number | undefined;
+            readonly updateInterval?: number | undefined;
+            readonly height?: string | number | undefined;
+            readonly itemSize?: import("../_components/virtual-list/interface.ts").ItemSizeValue | undefined;
+            readonly minItemSize?: string | number | null | undefined;
+            readonly listClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+            readonly itemClass?: import("../_components/virtual-list/interface.ts").ClassValue | undefined;
+            readonly estimatedSize?: number | undefined;
+            readonly component?: string | Record<string, unknown> | undefined;
+            readonly listAttrs?: Record<string, unknown> | undefined;
+            readonly contentWrapperAttrs?: Record<string, unknown> | undefined;
+            readonly contentAttrs?: Record<string, unknown> | undefined;
+            readonly listStyle?: import("vue").CSSProperties | undefined;
+            readonly cache?: import("virtua").CacheSnapshot | undefined;
+            readonly onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            readonly onScroll?: ((_ev: Event) => any) | undefined;
+            readonly onHidden?: (() => any) | undefined;
+            readonly onVisible?: (() => any) | undefined;
+            readonly onResize?: (() => any) | undefined;
+            readonly onReachBottom?: ((_ev: Event) => any) | undefined;
+            readonly onScrollStart?: (() => any) | undefined;
+            readonly onScrollEnd?: (() => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition">;
+        $attrs: import("vue").Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "update", _startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => void) & ((event: "scroll", _ev: Event) => void) & ((event: "hidden") => void) & ((event: "visible") => void) & ((event: "resize") => void) & ((event: "reachBottom", _ev: Event) => void) & ((event: "scrollStart") => void) & ((event: "scrollEnd") => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            items: {
+                type: import("vue").PropType<unknown[]>;
+                default: () => never[];
+            };
+            height: {
+                type: import("vue").PropType<number | string>;
+                default: undefined;
+            };
+            keyField: {
+                type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+                default: string;
+            };
+            direction: {
+                type: import("vue").PropType<"vertical" | "horizontal">;
+                default: string;
+            };
+            listTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemTag: {
+                type: StringConstructor;
+                default: string;
+            };
+            itemSize: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+                default: undefined;
+            };
+            gridItems: NumberConstructor;
+            itemSecondarySize: NumberConstructor;
+            minItemSize: {
+                type: import("vue").PropType<number | string | null>;
+                default: undefined;
+            };
+            sizeField: StringConstructor;
+            typeField: StringConstructor;
+            buffer: NumberConstructor;
+            shift: BooleanConstructor;
+            cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+            prerender: NumberConstructor;
+            emitUpdate: BooleanConstructor;
+            disableTransform: BooleanConstructor;
+            flowMode: BooleanConstructor;
+            hiddenPosition: NumberConstructor;
+            updateInterval: NumberConstructor;
+            skipHover: BooleanConstructor;
+            enabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            listClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            itemClass: {
+                type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+            };
+            threshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            fixedSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            estimatedSize: {
+                type: NumberConstructor;
+                default: undefined;
+            };
+            component: {
+                type: import("vue").PropType<string | Record<string, unknown>>;
+                default: undefined;
+            };
+            listAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentWrapperAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            contentAttrs: {
+                type: import("vue").PropType<Record<string, unknown> | undefined>;
+                default: undefined;
+            };
+            listStyle: {
+                type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+                default: undefined;
+            };
+            paddingPosition: {
+                type: import("vue").PropType<"content" | "list">;
+                default: string;
+            };
+            scrollbar: {
+                type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+            onScroll?: ((_ev: Event) => any) | undefined;
+            onHidden?: (() => any) | undefined;
+            onVisible?: (() => any) | undefined;
+            onResize?: (() => any) | undefined;
+            onReachBottom?: ((_ev: Event) => any) | undefined;
+            onScrollStart?: (() => any) | undefined;
+            onScrollEnd?: (() => any) | undefined;
+        }>, {
+            scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+            findItemIndex: (offset: number) => number;
+            getItemOffset: (index: number) => number;
+            getItemSize: (index: number) => number;
+            cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+            restoreCache: () => boolean;
+            updateVisibleItems: () => void;
+            scrollToBottom: () => void;
+            forceUpdate: () => void;
+            getDynamicItemSize: (_item: unknown, index?: number) => number;
+            scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+            scroll: (_ev: Event) => any;
+            hidden: () => any;
+            visible: () => any;
+            resize: () => any;
+            reachBottom: (_ev: Event) => any;
+            scrollStart: () => any;
+            scrollEnd: () => any;
+        }, string, {
+            shift: boolean;
+            scrollbar: boolean | import("../index.ts").ScrollbarProps;
+            enabled: boolean;
+            emitUpdate: boolean;
+            disableTransform: boolean;
+            flowMode: boolean;
+            skipHover: boolean;
+            items: unknown[];
+            height: string | number;
+            keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+            direction: "horizontal" | "vertical";
+            listTag: string;
+            itemTag: string;
+            itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+            minItemSize: string | number | null;
+            threshold: number;
+            fixedSize: boolean;
+            estimatedSize: number;
+            component: string | Record<string, unknown>;
+            listAttrs: Record<string, unknown> | undefined;
+            contentWrapperAttrs: Record<string, unknown> | undefined;
+            contentAttrs: Record<string, unknown> | undefined;
+            listStyle: import("vue").CSSProperties | undefined;
+            paddingPosition: "content" | "list";
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<{
+        shift: boolean;
+        scrollbar: boolean | import("../index.ts").ScrollbarProps;
+        enabled: boolean;
+        emitUpdate: boolean;
+        disableTransform: boolean;
+        flowMode: boolean;
+        skipHover: boolean;
+        items: unknown[];
+        height: string | number;
+        keyField: string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey);
+        direction: "horizontal" | "vertical";
+        listTag: string;
+        itemTag: string;
+        itemSize: import("../_components/virtual-list/interface.ts").ItemSizeValue;
+        minItemSize: string | number | null;
+        threshold: number;
+        fixedSize: boolean;
+        estimatedSize: number;
+        component: string | Record<string, unknown>;
+        listAttrs: Record<string, unknown> | undefined;
+        contentWrapperAttrs: Record<string, unknown> | undefined;
+        contentAttrs: Record<string, unknown> | undefined;
+        listStyle: import("vue").CSSProperties | undefined;
+        paddingPosition: "content" | "list";
+    }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        items: {
+            type: import("vue").PropType<unknown[]>;
+            default: () => never[];
+        };
+        height: {
+            type: import("vue").PropType<number | string>;
+            default: undefined;
+        };
+        keyField: {
+            type: import("vue").PropType<string | ((item: unknown, index: number) => import("../_components/virtual-list/interface.ts").VirtualItemKey)>;
+            default: string;
+        };
+        direction: {
+            type: import("vue").PropType<"vertical" | "horizontal">;
+            default: string;
+        };
+        listTag: {
+            type: StringConstructor;
+            default: string;
+        };
+        itemTag: {
+            type: StringConstructor;
+            default: string;
+        };
+        itemSize: {
+            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ItemSizeValue>;
+            default: undefined;
+        };
+        gridItems: NumberConstructor;
+        itemSecondarySize: NumberConstructor;
+        minItemSize: {
+            type: import("vue").PropType<number | string | null>;
+            default: undefined;
+        };
+        sizeField: StringConstructor;
+        typeField: StringConstructor;
+        buffer: NumberConstructor;
+        shift: BooleanConstructor;
+        cache: import("vue").PropType<import("virtua").CacheSnapshot>;
+        prerender: NumberConstructor;
+        emitUpdate: BooleanConstructor;
+        disableTransform: BooleanConstructor;
+        flowMode: BooleanConstructor;
+        hiddenPosition: NumberConstructor;
+        updateInterval: NumberConstructor;
+        skipHover: BooleanConstructor;
+        enabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        listClass: {
+            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+        };
+        itemClass: {
+            type: import("vue").PropType<import("../_components/virtual-list/interface.ts").ClassValue>;
+        };
+        threshold: {
+            type: NumberConstructor;
+            default: number;
+        };
+        fixedSize: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        estimatedSize: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+        component: {
+            type: import("vue").PropType<string | Record<string, unknown>>;
+            default: undefined;
+        };
+        listAttrs: {
+            type: import("vue").PropType<Record<string, unknown> | undefined>;
+            default: undefined;
+        };
+        contentWrapperAttrs: {
+            type: import("vue").PropType<Record<string, unknown> | undefined>;
+            default: undefined;
+        };
+        contentAttrs: {
+            type: import("vue").PropType<Record<string, unknown> | undefined>;
+            default: undefined;
+        };
+        listStyle: {
+            type: import("vue").PropType<import("vue").CSSProperties | undefined>;
+            default: undefined;
+        };
+        paddingPosition: {
+            type: import("vue").PropType<"content" | "list">;
+            default: string;
+        };
+        scrollbar: {
+            type: import("vue").PropType<boolean | import("../index.ts").ScrollbarProps>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+        onScroll?: ((_ev: Event) => any) | undefined;
+        onHidden?: (() => any) | undefined;
+        onVisible?: (() => any) | undefined;
+        onResize?: (() => any) | undefined;
+        onReachBottom?: ((_ev: Event) => any) | undefined;
+        onScrollStart?: (() => any) | undefined;
+        onScrollEnd?: (() => any) | undefined;
+    }>, "scrollTo" | "scrollToItem" | "scrollToPosition" | "findItemIndex" | "getItemOffset" | "getItemSize" | "cacheSnapshot" | "restoreCache" | "updateVisibleItems" | "scrollToBottom" | "forceUpdate" | "getDynamicItemSize" | ("shift" | "scrollbar" | "enabled" | "emitUpdate" | "disableTransform" | "flowMode" | "skipHover" | "items" | "height" | "keyField" | "direction" | "listTag" | "itemTag" | "itemSize" | "minItemSize" | "threshold" | "fixedSize" | "estimatedSize" | "component" | "listAttrs" | "contentWrapperAttrs" | "contentAttrs" | "listStyle" | "paddingPosition")> & {
+        scrollToItem: (index: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+        scrollToPosition: (position: number, options?: import("../_components/virtual-list/interface.ts").ScrollToOptions) => void;
+        findItemIndex: (offset: number) => number;
+        getItemOffset: (index: number) => number;
+        getItemSize: (index: number) => number;
+        cacheSnapshot: () => import("virtua").CacheSnapshot | undefined;
+        restoreCache: () => boolean;
+        updateVisibleItems: () => void;
+        scrollToBottom: () => void;
+        forceUpdate: () => void;
+        getDynamicItemSize: (_item: unknown, index?: number) => number;
+        scrollTo: (options: import("../_components/virtual-list/interface.ts").ScrollOptions) => void;
+    } & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            before?: (props: {}) => any;
+        } & {
+            item?: (props: {
+                item: any;
+                index: number;
+                active: boolean;
+                itemWithSize: undefined;
+            }) => any;
+        } & {
+            default?: (props: {
+                item: any;
+                index: number;
+                active: boolean;
+                itemWithSize: undefined;
+            }) => any;
+        } & {
+            after?: (props: {}) => any;
+        } & {
+            empty?: (props: {}) => any;
+        };
+    }) | undefined>;
+    scrollIntoView: (options: import("../_components/virtual-list/interface.ts").ScrollIntoViewOptions) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    scroll: () => void;
+    reachBottom: () => void;
+    pageSizeChange: (_pageSize: number) => void;
+    pageChange: (_page: number) => void;
 }, string, {
     split: boolean;
     size: "small" | "medium" | "large";
@@ -226,41 +2734,59 @@ declare const List: {
     bordered: boolean;
     maxHeight: string | number;
     hoverable: boolean;
-}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        item?: (props: {
+            item: unknown;
+            index: number;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        'scroll-loading'?: (props: {}) => any;
+    } & {
+        header?: (props: {}) => any;
+    } & {
+        item?: (props: {
+            item: any;
+            index: number;
+        }) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+}) & {
     Item: {
-        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-            actionLayout: {
-                type: import("vue").PropType<import("../index.ts").Direction>;
-                default: string;
-            };
-        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-            actionLayout: "horizontal" | "vertical";
-        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+            actionLayout?: import("../index.ts").Direction;
+        }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            actionLayout: import("../index.ts").Direction;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
             C: {};
             M: {};
             Defaults: {};
-        }, Readonly<import("vue").ExtractPropTypes<{
-            actionLayout: {
-                type: import("vue").PropType<import("../index.ts").Direction>;
-                default: string;
-            };
-        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
-            actionLayout: "horizontal" | "vertical";
+        }, Readonly<{
+            actionLayout?: import("../index.ts").Direction;
+        }> & Readonly<{}>, {}, {}, {}, {}, {
+            actionLayout: import("../index.ts").Direction;
         }>;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-        actionLayout: {
-            type: import("vue").PropType<import("../index.ts").Direction>;
-            default: string;
+    } & import("vue").ComponentOptionsBase<Readonly<{
+        actionLayout?: import("../index.ts").Direction;
+    }> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        actionLayout: import("../index.ts").Direction;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: () => import("vue").VNode[];
+            actions?: () => import("vue").VNode[];
+            extra?: () => import("vue").VNode[];
+            meta?: () => import("vue").VNode[];
         };
-    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-        actionLayout: "horizontal" | "vertical";
-    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    }) & {
         Meta: {
             new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                 title: StringConstructor;