@sdata/web-vue 2.1.1 → 2.2.1

package/es/_components/virtual-list/virtual-list.js

@@ -1,122 +1,6 @@
-import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export-helper.js";
-import virtual_list_vue_vue_type_script_lang_default from "./virtual-list.vue_vue_type_script_lang.js";
+import virtual_list_vue_vue_type_script_setup_true_lang_default from "./virtual-list.vue_vue_type_script_setup_true_lang.js";
 /* empty css                                             */
-import { Fragment, createBlock, createElementBlock, mergeProps, normalizeClass, normalizeStyle, openBlock, renderList, renderSlot, resolveComponent, resolveDynamicComponent, toHandlers, withCtx } from "vue";
 //#region components/_components/virtual-list/virtual-list.vue
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-	const _component_DynamicScrollerItem = resolveComponent("DynamicScrollerItem");
-	return openBlock(), createElementBlock("div", {
-		ref: "scrollbarHostRef",
-		class: normalizeClass(_ctx.hostClassNames),
-		style: normalizeStyle(_ctx.containerOuterStyle)
-	}, [_ctx.isCompatMode ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.mergedCompatComponent.container), {
-		key: 0,
-		ref: "viewportRef",
-		class: normalizeClass(`${_ctx.prefixCls}-scroller`),
-		style: normalizeStyle(_ctx.compatViewportStyle),
-		onScroll: _ctx.onCompatScroll
-	}, {
-		default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.mergedCompatComponent.list), mergeProps(_ctx.props.listAttrs, { style: _ctx.compatListStyle }), {
-			default: withCtx(() => [
-				renderSlot(_ctx.$slots, "before"),
-				_ctx.hasCompatContentWrapper ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.mergedCompatComponent.content), mergeProps({ key: 0 }, _ctx.props.contentWrapperAttrs, { style: _ctx.compatContentWrapperStyle }), {
-					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.compatCurrentList, (item, index) => {
-						return openBlock(), createBlock(resolveDynamicComponent(_ctx.mergedCompatComponent.item), mergeProps({ key: _ctx.getCompatItemKey(item, _ctx.compatStart + index) }, { ref_for: true }, _ctx.props.contentAttrs, {
-							ref_for: true,
-							ref: (element) => _ctx.setCompatItemRef(_ctx.getCompatItemKey(item, _ctx.compatStart + index), element),
-							style: _ctx.getCompatContentStyle(index)
-						}), {
-							default: withCtx(() => [renderSlot(_ctx.$slots, "item", {
-								item,
-								index: _ctx.compatStart + index,
-								active: true,
-								itemWithSize: void 0
-							}, () => [renderSlot(_ctx.$slots, "default", {
-								item,
-								index: _ctx.compatStart + index,
-								active: true,
-								itemWithSize: void 0
-							})])]),
-							_: 2
-						}, 1040, ["style"]);
-					}), 128))]),
-					_: 3
-				}, 16, ["style"])) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.compatCurrentList, (item, index) => {
-					return openBlock(), createBlock(resolveDynamicComponent(_ctx.mergedCompatComponent.content), mergeProps({ key: _ctx.getCompatItemKey(item, _ctx.compatStart + index) }, { ref_for: true }, _ctx.props.contentAttrs, {
-						ref_for: true,
-						ref: (element) => _ctx.setCompatItemRef(_ctx.getCompatItemKey(item, _ctx.compatStart + index), element),
-						style: _ctx.getCompatContentStyle(index)
-					}), {
-						default: withCtx(() => [renderSlot(_ctx.$slots, "item", {
-							item,
-							index: _ctx.compatStart + index,
-							active: true,
-							itemWithSize: void 0
-						}, () => [renderSlot(_ctx.$slots, "default", {
-							item,
-							index: _ctx.compatStart + index,
-							active: true,
-							itemWithSize: void 0
-						})])]),
-						_: 2
-					}, 1040, ["style"]);
-				}), 128)),
-				renderSlot(_ctx.$slots, "after")
-			]),
-			_: 3
-		}, 16, ["style"]))]),
-		_: 3
-	}, 40, [
-		"class",
-		"style",
-		"onScroll"
-	])) : (openBlock(), createBlock(resolveDynamicComponent(_ctx.currentScroller), mergeProps({
-		key: 1,
-		ref: "scrollerRef",
-		class: `${_ctx.prefixCls}-scroller`,
-		style: _ctx.scrollerStyle
-	}, _ctx.scrollerProps, toHandlers(_ctx.scrollerListeners)), {
-		before: withCtx(() => [renderSlot(_ctx.$slots, "before")]),
-		default: withCtx((slotProps) => [_ctx.isDynamicScroller ? (openBlock(), createBlock(_component_DynamicScrollerItem, {
-			key: 0,
-			item: slotProps.item,
-			active: slotProps.active,
-			index: slotProps.index,
-			"size-dependencies": null
-		}, {
-			default: withCtx(() => [renderSlot(_ctx.$slots, "item", {
-				item: slotProps.item,
-				index: slotProps.index,
-				active: slotProps.active,
-				itemWithSize: _ctx.getSlotItemWithSize(slotProps)
-			}, () => [renderSlot(_ctx.$slots, "default", {
-				item: slotProps.item,
-				index: slotProps.index,
-				active: slotProps.active,
-				itemWithSize: _ctx.getSlotItemWithSize(slotProps)
-			})])]),
-			_: 2
-		}, 1032, [
-			"item",
-			"active",
-			"index"
-		])) : renderSlot(_ctx.$slots, "item", {
-			key: 1,
-			item: slotProps.item,
-			index: slotProps.index,
-			active: slotProps.active,
-			itemWithSize: _ctx.getSlotItemWithSize(slotProps)
-		}, () => [renderSlot(_ctx.$slots, "default", {
-			item: slotProps.item,
-			index: slotProps.index,
-			active: slotProps.active,
-			itemWithSize: _ctx.getSlotItemWithSize(slotProps)
-		})])]),
-		empty: withCtx(() => [renderSlot(_ctx.$slots, "empty")]),
-		after: withCtx(() => [renderSlot(_ctx.$slots, "after")]),
-		_: 3
-	}, 16, ["class", "style"]))], 6);
-}
-var virtual_list_default = /*#__PURE__*/ _plugin_vue_export_helper_default(virtual_list_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+var virtual_list_default = virtual_list_vue_vue_type_script_setup_true_lang_default;
 //#endregion
 export { virtual_list_default as default };

package/es/_components/virtual-list/virtual-list.vue.d.ts

@@ -1,17 +1,76 @@
-import { type CSSProperties, type Component, PropType } from 'vue';
-import { type CacheSnapshot, type ClassValue, type DynamicScrollerExposed, type ItemSizeValue, type KeyFieldValue, type KeyValue, type RecycleScrollerExposed, type ScrollDirection } from 'vue-virtual-scroller';
+import { type CSSProperties, PropType } from 'vue';
+import { type CacheSnapshot, type ClassValue, type ItemSizeValue, type KeyFieldValue, type ScrollDirection, type ScrollToOptions } from 'vue-virtual-scroller';
 import type { ScrollbarProps } from '../../scrollbar';
-import type { VirtualItemKey } from './interface';
-type ScrollerExpose = RecycleScrollerExposed<any, KeyValue> | DynamicScrollerExposed<any>;
-type ScrollerSlotProps = {
+import type { ScrollOptions } from './interface';
+declare var __VLS_17: {}, __VLS_31: {
     item: unknown;
     index: number;
     active: boolean;
-    itemWithSize?: Record<string, unknown>;
+    itemWithSize: undefined;
+}, __VLS_33: {
+    item: unknown;
+    index: number;
+    active: boolean;
+    itemWithSize: undefined;
+}, __VLS_41: {
+    item: unknown;
+    index: number;
+    active: boolean;
+    itemWithSize: undefined;
+}, __VLS_43: {
+    item: unknown;
+    index: number;
+    active: boolean;
+    itemWithSize: undefined;
+}, __VLS_45: {}, __VLS_56: {}, __VLS_65: {
+    item: any;
+    index: any;
+    active: any;
+    itemWithSize: Record<string, unknown> | undefined;
+}, __VLS_67: {
+    item: any;
+    index: any;
+    active: any;
+    itemWithSize: Record<string, unknown> | undefined;
+}, __VLS_69: {
+    item: any;
+    index: any;
+    active: any;
+    itemWithSize: Record<string, unknown> | undefined;
+}, __VLS_71: {
+    item: any;
+    index: any;
+    active: any;
+    itemWithSize: Record<string, unknown> | undefined;
+}, __VLS_74: {}, __VLS_77: {};
+type __VLS_Slots = {} & {
+    before?: (props: typeof __VLS_17) => any;
+} & {
+    item?: (props: typeof __VLS_31) => any;
+} & {
+    default?: (props: typeof __VLS_33) => any;
+} & {
+    item?: (props: typeof __VLS_41) => any;
+} & {
+    default?: (props: typeof __VLS_43) => any;
+} & {
+    after?: (props: typeof __VLS_45) => any;
+} & {
+    before?: (props: typeof __VLS_56) => any;
+} & {
+    item?: (props: typeof __VLS_65) => any;
+} & {
+    default?: (props: typeof __VLS_67) => any;
+} & {
+    item?: (props: typeof __VLS_69) => any;
+} & {
+    default?: (props: typeof __VLS_71) => any;
+} & {
+    empty?: (props: typeof __VLS_74) => any;
+} & {
+    after?: (props: typeof __VLS_77) => any;
 };
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     items: {
         type: PropType<unknown[]>;
         default: () => never[];
@@ -109,169 +168,27 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
         default: boolean;
     };
 }>, {
-    prefixCls: string;
-    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
-        items: {
-            type: PropType<unknown[]>;
-            default: () => never[];
-        };
-        height: {
-            type: PropType<number | string>;
-            default: undefined;
-        };
-        keyField: {
-            type: PropType<KeyFieldValue<any>>;
-            default: string;
-        };
-        direction: {
-            type: PropType<ScrollDirection>;
-            default: string;
-        };
-        listTag: {
-            type: StringConstructor;
-            default: string;
-        };
-        itemTag: {
-            type: StringConstructor;
-            default: string;
-        };
-        itemSize: {
-            type: PropType<ItemSizeValue<any>>;
-            default: undefined;
-        };
-        gridItems: NumberConstructor;
-        itemSecondarySize: NumberConstructor;
-        minItemSize: {
-            type: PropType<number | string | null>;
-            default: undefined;
-        };
-        sizeField: StringConstructor;
-        typeField: StringConstructor;
-        buffer: NumberConstructor;
-        shift: BooleanConstructor;
-        cache: PropType<CacheSnapshot>;
-        prerender: NumberConstructor;
-        emitUpdate: BooleanConstructor;
-        disableTransform: BooleanConstructor;
-        flowMode: BooleanConstructor;
-        hiddenPosition: NumberConstructor;
-        updateInterval: NumberConstructor;
-        skipHover: BooleanConstructor;
-        enabled: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        listClass: {
-            type: PropType<ClassValue>;
-        };
-        itemClass: {
-            type: PropType<ClassValue>;
-        };
-        threshold: {
-            type: NumberConstructor;
-            default: number;
-        };
-        fixedSize: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        estimatedSize: {
-            type: NumberConstructor;
-            default: undefined;
-        };
-        component: {
-            type: PropType<keyof HTMLElementTagNameMap | Record<string, unknown>>;
-            default: undefined;
-        };
-        listAttrs: {
-            type: PropType<Record<string, unknown> | undefined>;
-            default: undefined;
-        };
-        contentWrapperAttrs: {
-            type: PropType<Record<string, unknown> | undefined>;
-            default: undefined;
-        };
-        contentAttrs: {
-            type: PropType<Record<string, unknown> | undefined>;
-            default: undefined;
-        };
-        listStyle: {
-            type: PropType<CSSProperties | undefined>;
-            default: undefined;
-        };
-        paddingPosition: {
-            type: PropType<"content" | "list">;
-            default: string;
-        };
-        scrollbar: {
-            type: PropType<boolean | 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;
-    }> & {}>;
-    hostClassNames: import("vue").ComputedRef<string[]>;
-    scrollbarHostRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
-    scrollerRef: import("vue").Ref<ScrollerExpose | undefined, ScrollerExpose | undefined>;
-    viewportRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
-    isCompatMode: import("vue").ComputedRef<boolean>;
-    mergedCompatComponent: import("vue").ComputedRef<{
-        container: string;
-        list: string;
-        content: string;
-        item: string;
-    }>;
-    hasCompatContentWrapper: import("vue").ComputedRef<boolean>;
-    compatViewportStyle: import("vue").ComputedRef<CSSProperties>;
-    compatListStyle: import("vue").ComputedRef<CSSProperties | undefined>;
-    compatContentStyle: import("vue").ComputedRef<CSSProperties | undefined>;
-    compatContentWrapperStyle: import("vue").ComputedRef<CSSProperties | undefined>;
-    compatCurrentList: import("vue").ComputedRef<unknown[]>;
-    compatStart: import("vue").ComputedRef<number>;
-    getCompatItemKey: (item: unknown, index: number) => VirtualItemKey;
-    setCompatItemRef: (key: VirtualItemKey, value: unknown) => void;
-    getCompatContentStyle: (index: number) => CSSProperties | undefined;
-    onCompatScroll: (ev: Event) => void;
-    currentScroller: import("vue").ComputedRef<Component>;
-    isDynamicScroller: import("vue").ComputedRef<boolean>;
-    containerOuterStyle: import("vue").ComputedRef<{
-        height: string;
-    } | undefined>;
-    scrollerStyle: import("vue").ComputedRef<CSSProperties>;
-    scrollerProps: import("vue").ComputedRef<Record<string, unknown>>;
-    scrollerListeners: import("vue").ComputedRef<{
-        resize: () => void;
-        visible: () => void;
-        hidden?: undefined;
-        update?: undefined;
-        scrollStart?: undefined;
-        scrollEnd?: undefined;
-    } | {
-        resize: () => void;
-        visible: () => void;
-        hidden: () => void;
-        update: (startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void;
-        scrollStart: () => void;
-        scrollEnd: () => void;
-    }>;
-    getSlotItemWithSize: (slotProps: ScrollerSlotProps) => Record<string, unknown> | undefined;
-    onScroll: (ev: Event) => void;
+    scrollToItem: (index: number, options?: ScrollToOptions) => void;
+    scrollToPosition: (position: number, options?: ScrollToOptions) => void;
+    findItemIndex: (offset: number) => number;
+    getItemOffset: (index: number) => number;
+    getItemSize: (index: number) => number;
+    cacheSnapshot: () => CacheSnapshot | undefined;
+    restoreCache: (snapshot: CacheSnapshot | null | undefined) => boolean;
+    updateVisibleItems: (itemsChanged: boolean, checkPositionDiff?: boolean) => void;
+    scrollToBottom: () => void;
+    forceUpdate: (clear?: boolean) => void;
+    getDynamicItemSize: (item: unknown, index?: number) => number;
+    scrollTo: (options: ScrollOptions) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    scroll: (_ev: Event) => true;
-    reachBottom: (_ev: Event) => true;
-    resize: () => true;
-    visible: () => true;
-    hidden: () => true;
-    update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => true;
-    scrollStart: () => true;
-    scrollEnd: () => true;
+    update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+    scroll: (_ev: Event) => any;
+    resize: () => any;
+    visible: () => any;
+    reachBottom: (_ev: Event) => any;
+    hidden: () => any;
+    scrollStart: () => any;
+    scrollEnd: () => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     items: {
         type: PropType<unknown[]>;
@@ -372,16 +289,14 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>> & 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;
+    onVisible?: (() => any) | undefined;
     onReachBottom?: ((_ev: Event) => any) | undefined;
+    onHidden?: (() => any) | undefined;
     onScrollStart?: (() => any) | undefined;
     onScrollEnd?: (() => any) | undefined;
 }>, {
     shift: boolean;
-    scrollbar: boolean | ScrollbarProps;
-    enabled: boolean;
     fixedSize: boolean;
     estimatedSize: number;
     emitUpdate: boolean;
@@ -396,6 +311,7 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     itemTag: string;
     itemSize: ItemSizeValue<any>;
     minItemSize: string | number | null;
+    enabled: boolean;
     threshold: number;
     component: Record<string, unknown> | keyof HTMLElementTagNameMap;
     listAttrs: Record<string, unknown> | undefined;
@@ -403,152 +319,13 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     contentAttrs: Record<string, unknown> | undefined;
     listStyle: CSSProperties | undefined;
     paddingPosition: "content" | "list";
-}, {}, {
-    RecycleScroller: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
-        emit: ((evt: "visible") => void) & ((evt: "hidden") => void) & ((evt: "resize") => void) & ((evt: "update", startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void) & ((evt: "scrollStart") => void) & ((evt: "scrollEnd") => void);
-        slots: Readonly<{
-            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        }> & {
-            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        };
-        attrs: any;
-    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-        props: {
-            readonly onResize?: (() => any) | undefined | undefined;
-            readonly onVisible?: (() => any) | undefined | undefined;
-            readonly onHidden?: (() => any) | undefined | undefined;
-            readonly onUpdate?: ((startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => any) | undefined | undefined;
-            readonly onScrollStart?: (() => any) | undefined | undefined;
-            readonly onScrollEnd?: (() => any) | undefined | undefined;
-            items: TItem[];
-            keyField?: KeyFieldValue<any> | undefined;
-            direction?: ScrollDirection | undefined;
-            listTag?: string | undefined;
-            itemTag?: string | undefined;
-            itemSize?: ItemSizeValue<TItem> | undefined;
-            gridItems?: number | undefined;
-            itemSecondarySize?: number | undefined;
-            minItemSize?: number | string | null | undefined;
-            sizeField?: string | undefined;
-            typeField?: string | undefined;
-            buffer?: number | undefined;
-            pageMode?: boolean | undefined;
-            scrollParent?: (HTMLElement | Window) | undefined;
-            shift?: boolean | undefined;
-            cache?: CacheSnapshot | undefined;
-            prerender?: number | undefined;
-            emitUpdate?: boolean | undefined;
-            disableTransform?: boolean | undefined;
-            flowMode?: boolean | undefined;
-            hiddenPosition?: number | undefined;
-            updateInterval?: number | undefined;
-            skipHover?: boolean | undefined;
-            enabled?: boolean | undefined;
-            listClass?: ClassValue | undefined;
-            itemClass?: ClassValue | undefined;
-        } & import("vue").PublicProps;
-        expose(exposed: import("vue").ShallowUnwrapRef<RecycleScrollerExposed<TItem, KeyValue>>): void;
-        attrs: any;
-        slots: Readonly<{
-            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        }> & {
-            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        };
-        emit: ((evt: "visible") => void) & ((evt: "hidden") => void) & ((evt: "resize") => void) & ((evt: "update", startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void) & ((evt: "scrollStart") => void) & ((evt: "scrollEnd") => void);
-    }>) => import("vue").VNode & {
-        __ctx?: Awaited<typeof __VLS_setup>;
-    };
-    DynamicScroller: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
-        emit: ((evt: "visible") => void) & ((evt: "resize") => void);
-        slots: Readonly<{
-            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        }> & {
-            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        };
-        attrs: any;
-    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-        props: {
-            readonly onResize?: (() => any) | undefined | undefined;
-            readonly onVisible?: (() => any) | undefined | undefined;
-            items: TItem[];
-            keyField?: KeyFieldValue<any> | undefined;
-            direction?: ScrollDirection | undefined;
-            listTag?: string | undefined;
-            itemTag?: string | undefined;
-            minItemSize: number | string;
-            shift?: boolean | undefined;
-            cache?: CacheSnapshot | undefined;
-            disableTransform?: boolean | undefined;
-            flowMode?: boolean | undefined;
-            hiddenPosition?: number | undefined;
-            enabled?: boolean | undefined;
-            pageMode?: boolean | undefined;
-            scrollParent?: (HTMLElement | Window) | undefined;
-        } & import("vue").PublicProps;
-        expose(exposed: import("vue").ShallowUnwrapRef<DynamicScrollerExposed<TItem>>): void;
-        attrs: any;
-        slots: Readonly<{
-            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        }> & {
-            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
-            before?: () => unknown;
-            after?: () => unknown;
-            empty?: () => unknown;
-        };
-        emit: ((evt: "visible") => void) & ((evt: "resize") => void);
-    }>) => import("vue").VNode & {
-        __ctx?: Awaited<typeof __VLS_setup>;
-    };
-    DynamicScrollerItem: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
-        emit: (evt: "resize", id: KeyValue) => void;
-        slots: Readonly<{
-            default?: () => unknown;
-        }> & {
-            default?: () => unknown;
-        };
-        attrs: any;
-    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-        props: {
-            readonly onResize?: ((id: KeyValue) => any) | undefined | undefined;
-            item: TItem;
-            watchData?: boolean | undefined;
-            active: boolean;
-            index?: number | undefined;
-            sizeDependencies?: (Record<string, unknown> | unknown[] | null) | undefined;
-            emitResize?: boolean | undefined;
-            enabled?: boolean | undefined;
-            tag?: string | undefined;
-        } & import("vue").PublicProps;
-        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
-        attrs: any;
-        slots: Readonly<{
-            default?: () => unknown;
-        }> & {
-            default?: () => unknown;
-        };
-        emit: (evt: "resize", id: KeyValue) => void;
-    }>) => import("vue").VNode & {
-        __ctx?: Awaited<typeof __VLS_setup>;
-    };
-}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    scrollbar: boolean | ScrollbarProps;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};