@sdata/web-vue 1.2.0 → 1.3.0

package/es/tree-select/tree-select.vue.d.ts

@@ -0,0 +1,2796 @@
+import { CSSProperties, PropType, StyleValue } from 'vue';
+import { SelectViewValue } from '../_components/select-view/interface';
+import { Size } from '../_utils/constant';
+import pickSubCompSlots from '../_utils/pick-sub-comp-slots';
+import { Data } from '../_utils/types';
+import { ScrollbarProps } from '../scrollbar';
+import { TreeFieldNames, TreeNodeData, TreeProps, TreeNodeKey, Node } from '../tree/interface';
+import { TriggerProps } from '../trigger';
+import { LabelValue } from './interface';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+    };
+    loading: {
+        type: BooleanConstructor;
+    };
+    error: {
+        type: BooleanConstructor;
+    };
+    size: {
+        type: PropType<Size>;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowSearch: {
+        type: PropType<boolean | {
+            retainInputValue?: boolean;
+        }>;
+        default: (props: Data) => boolean;
+    };
+    allowClear: {
+        type: BooleanConstructor;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    maxTagCount: {
+        type: NumberConstructor;
+    };
+    multiple: {
+        type: BooleanConstructor;
+    };
+    defaultValue: {
+        type: PropType<string | number | Array<string | number> | LabelValue | LabelValue[]>;
+    };
+    modelValue: {
+        type: PropType<string | number | Array<string | number> | LabelValue | LabelValue[]>;
+    };
+    fieldNames: {
+        type: PropType<TreeFieldNames>;
+    };
+    data: {
+        type: PropType<TreeNodeData[]>;
+        default: () => never[];
+    };
+    labelInValue: {
+        type: BooleanConstructor;
+    };
+    treeCheckable: {
+        type: BooleanConstructor;
+    };
+    treeCheckStrictly: {
+        type: BooleanConstructor;
+    };
+    treeCheckedStrategy: {
+        type: PropType<"all" | "parent" | "child">;
+        default: string;
+    };
+    treeProps: {
+        type: PropType<Partial<TreeProps>>;
+    };
+    triggerProps: {
+        type: PropType<Partial<TriggerProps>>;
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+    };
+    dropdownStyle: {
+        type: PropType<CSSProperties>;
+    };
+    dropdownClassName: {
+        type: PropType<string | string[]>;
+    };
+    filterTreeNode: {
+        type: PropType<(searchKey: string, nodeData: TreeNodeData) => boolean>;
+    };
+    loadMore: {
+        type: PropType<(nodeData: TreeNodeData) => Promise<void>>;
+    };
+    disableFilter: {
+        type: BooleanConstructor;
+    };
+    popupContainer: {
+        type: PropType<string | HTMLElement>;
+    };
+    fallbackOption: {
+        type: PropType<boolean | ((key: number | string) => TreeNodeData | boolean)>;
+        default: boolean;
+    };
+    selectable: {
+        type: PropType<boolean | "leaf" | ((node: TreeNodeData, info: {
+            isLeaf: boolean;
+            level: number;
+        }) => boolean)>;
+        default: boolean;
+    };
+    scrollbar: {
+        type: PropType<boolean | ScrollbarProps>;
+        default: boolean;
+    };
+    showHeaderOnEmpty: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    showFooterOnEmpty: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    inputValue: {
+        type: StringConstructor;
+    };
+    defaultInputValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    refSelectView: import("vue").Ref<any, any>;
+    prefixCls: string;
+    TreeSelectEmpty: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | undefined;
+    selectedValue: import("vue").ComputedRef<LabelValue[]>;
+    selectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+    mergedDisabled: import("vue").ComputedRef<boolean>;
+    searchValue: import("vue").ComputedRef<string>;
+    panelVisible: import("vue").ComputedRef<boolean>;
+    isEmpty: import("vue").ComputedRef<boolean | undefined>;
+    computedFilterTreeNode: import("vue").ComputedRef<((node: TreeNodeData) => boolean) | undefined>;
+    isMultiple: import("vue").ComputedRef<boolean>;
+    selectViewValue: import("vue").ComputedRef<SelectViewValue[]>;
+    computedDropdownStyle: import("vue").ComputedRef<StyleValue[]>;
+    onSearchValueChange: (inputValue: string) => void;
+    onSelectChange(newVal: string[]): void;
+    onVisibleChange: (visible: boolean) => void;
+    onInnerClear(): void;
+    pickSubCompSlots: typeof pickSubCompSlots;
+    isSelectable: (node: TreeNodeData, info: {
+        level: number;
+        isLeaf: boolean;
+    }) => boolean;
+    isCheckable: import("vue").ComputedRef<false | ((node: TreeNodeData, info: {
+        level: number;
+        isLeaf: boolean;
+    }) => boolean)>;
+    onBlur: () => void;
+    onItemRemove(id: string): void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: string | number | LabelValue | Array<string | number> | LabelValue[] | undefined) => true;
+    'update:modelValue': (value: string | number | LabelValue | Array<string | number> | LabelValue[] | undefined) => true;
+    'update:inputValue': (inputValue: string) => true;
+    'popup-visible-change': (visible: boolean) => true;
+    'update:popupVisible': (visible: boolean) => true;
+    search: (searchKey: string) => true;
+    clear: () => true;
+    inputValueChange: (inputValue: string) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+    };
+    loading: {
+        type: BooleanConstructor;
+    };
+    error: {
+        type: BooleanConstructor;
+    };
+    size: {
+        type: PropType<Size>;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowSearch: {
+        type: PropType<boolean | {
+            retainInputValue?: boolean;
+        }>;
+        default: (props: Data) => boolean;
+    };
+    allowClear: {
+        type: BooleanConstructor;
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    maxTagCount: {
+        type: NumberConstructor;
+    };
+    multiple: {
+        type: BooleanConstructor;
+    };
+    defaultValue: {
+        type: PropType<string | number | Array<string | number> | LabelValue | LabelValue[]>;
+    };
+    modelValue: {
+        type: PropType<string | number | Array<string | number> | LabelValue | LabelValue[]>;
+    };
+    fieldNames: {
+        type: PropType<TreeFieldNames>;
+    };
+    data: {
+        type: PropType<TreeNodeData[]>;
+        default: () => never[];
+    };
+    labelInValue: {
+        type: BooleanConstructor;
+    };
+    treeCheckable: {
+        type: BooleanConstructor;
+    };
+    treeCheckStrictly: {
+        type: BooleanConstructor;
+    };
+    treeCheckedStrategy: {
+        type: PropType<"all" | "parent" | "child">;
+        default: string;
+    };
+    treeProps: {
+        type: PropType<Partial<TreeProps>>;
+    };
+    triggerProps: {
+        type: PropType<Partial<TriggerProps>>;
+    };
+    popupVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultPopupVisible: {
+        type: BooleanConstructor;
+    };
+    dropdownStyle: {
+        type: PropType<CSSProperties>;
+    };
+    dropdownClassName: {
+        type: PropType<string | string[]>;
+    };
+    filterTreeNode: {
+        type: PropType<(searchKey: string, nodeData: TreeNodeData) => boolean>;
+    };
+    loadMore: {
+        type: PropType<(nodeData: TreeNodeData) => Promise<void>>;
+    };
+    disableFilter: {
+        type: BooleanConstructor;
+    };
+    popupContainer: {
+        type: PropType<string | HTMLElement>;
+    };
+    fallbackOption: {
+        type: PropType<boolean | ((key: number | string) => TreeNodeData | boolean)>;
+        default: boolean;
+    };
+    selectable: {
+        type: PropType<boolean | "leaf" | ((node: TreeNodeData, info: {
+            isLeaf: boolean;
+            level: number;
+        }) => boolean)>;
+        default: boolean;
+    };
+    scrollbar: {
+        type: PropType<boolean | ScrollbarProps>;
+        default: boolean;
+    };
+    showHeaderOnEmpty: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    showFooterOnEmpty: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    inputValue: {
+        type: StringConstructor;
+    };
+    defaultInputValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onChange?: ((value: string | number | (string | number)[] | LabelValue | LabelValue[] | undefined) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onSearch?: ((searchKey: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number | (string | number)[] | LabelValue | LabelValue[] | undefined) => any) | undefined;
+    "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
+    "onUpdate:inputValue"?: ((inputValue: string) => any) | undefined;
+    onInputValueChange?: ((inputValue: string) => any) | undefined;
+    "onPopup-visible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    error: boolean;
+    disabled: boolean;
+    loading: boolean;
+    data: TreeNodeData[];
+    allowClear: boolean;
+    popupVisible: boolean;
+    defaultPopupVisible: boolean;
+    multiple: boolean;
+    scrollbar: boolean | ScrollbarProps;
+    border: boolean;
+    showHeaderOnEmpty: boolean;
+    showFooterOnEmpty: boolean;
+    defaultInputValue: string;
+    allowSearch: boolean | {
+        retainInputValue?: boolean;
+    };
+    fallbackOption: boolean | ((key: number | string) => TreeNodeData | boolean);
+    selectable: boolean | "leaf" | ((node: TreeNodeData, info: {
+        isLeaf: boolean;
+        level: number;
+    }) => boolean);
+    disableFilter: boolean;
+    labelInValue: boolean;
+    treeCheckable: boolean;
+    treeCheckStrictly: boolean;
+    treeCheckedStrategy: "all" | "parent" | "child";
+}, {}, {
+    Trigger: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            popupVisible: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultPopupVisible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            trigger: {
+                type: PropType<import("..").TriggerEvent | import("..").TriggerEvent[]>;
+                default: string;
+            };
+            position: {
+                type: PropType<import("..").TriggerPosition>;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupOffset: {
+                type: NumberConstructor;
+                default: number;
+            };
+            popupTranslate: {
+                type: PropType<import("..").TriggerPopupTranslate>;
+            };
+            showArrow: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alignPoint: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupHoverStay: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            blurToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clickToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clickOutsideToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            unmountOnClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contentClass: {
+                type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+            };
+            contentStyle: {
+                type: PropType<CSSProperties>;
+            };
+            arrowClass: {
+                type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+            };
+            arrowStyle: {
+                type: PropType<CSSProperties>;
+            };
+            popupStyle: {
+                type: PropType<CSSProperties>;
+            };
+            animationName: {
+                type: StringConstructor;
+                default: string;
+            };
+            duration: {
+                type: PropType<number | {
+                    enter: number;
+                    leave: number;
+                }>;
+            };
+            mouseEnterDelay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            mouseLeaveDelay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            focusDelay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            autoFitPopupWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoFitPopupMinWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoFixPosition: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupContainer: {
+                type: PropType<string | HTMLElement>;
+            };
+            updateAtScroll: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoFitTransformOrigin: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hideEmpty: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            openedClass: {
+                type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+            };
+            autoFitPosition: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            renderToBody: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            preventFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            scrollToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            scrollToCloseDistance: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{
+            onResize?: (() => any) | undefined;
+            "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
+            onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
+            onShow?: (() => any) | undefined;
+            onHide?: (() => any) | undefined;
+        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            'update:popupVisible': (visible: boolean) => true;
+            popupVisibleChange: (visible: boolean) => true;
+            show: () => true;
+            hide: () => true;
+            resize: () => true;
+        }, import("vue").PublicProps, {
+            disabled: boolean;
+            unmountOnClose: boolean;
+            renderToBody: boolean;
+            position: "top" | "tl" | "tr" | "bottom" | "bl" | "br" | "left" | "lt" | "lb" | "right" | "rt" | "rb";
+            autoFitPosition: boolean;
+            popupVisible: boolean;
+            defaultPopupVisible: boolean;
+            trigger: "hover" | "click" | "focus" | "contextMenu" | ("hover" | "click" | "focus" | "contextMenu")[];
+            popupOffset: number;
+            showArrow: boolean;
+            alignPoint: boolean;
+            popupHoverStay: boolean;
+            blurToClose: boolean;
+            clickToClose: boolean;
+            clickOutsideToClose: boolean;
+            animationName: string;
+            mouseEnterDelay: number;
+            mouseLeaveDelay: number;
+            focusDelay: number;
+            autoFitPopupWidth: boolean;
+            autoFitPopupMinWidth: boolean;
+            autoFixPosition: boolean;
+            updateAtScroll: boolean;
+            autoFitTransformOrigin: boolean;
+            hideEmpty: boolean;
+            preventFocus: boolean;
+            scrollToClose: boolean;
+            scrollToCloseDistance: number;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            popupVisible: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultPopupVisible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            trigger: {
+                type: PropType<import("..").TriggerEvent | import("..").TriggerEvent[]>;
+                default: string;
+            };
+            position: {
+                type: PropType<import("..").TriggerPosition>;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupOffset: {
+                type: NumberConstructor;
+                default: number;
+            };
+            popupTranslate: {
+                type: PropType<import("..").TriggerPopupTranslate>;
+            };
+            showArrow: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alignPoint: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupHoverStay: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            blurToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clickToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            clickOutsideToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            unmountOnClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            contentClass: {
+                type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+            };
+            contentStyle: {
+                type: PropType<CSSProperties>;
+            };
+            arrowClass: {
+                type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+            };
+            arrowStyle: {
+                type: PropType<CSSProperties>;
+            };
+            popupStyle: {
+                type: PropType<CSSProperties>;
+            };
+            animationName: {
+                type: StringConstructor;
+                default: string;
+            };
+            duration: {
+                type: PropType<number | {
+                    enter: number;
+                    leave: number;
+                }>;
+            };
+            mouseEnterDelay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            mouseLeaveDelay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            focusDelay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            autoFitPopupWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoFitPopupMinWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoFixPosition: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupContainer: {
+                type: PropType<string | HTMLElement>;
+            };
+            updateAtScroll: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            autoFitTransformOrigin: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hideEmpty: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            openedClass: {
+                type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+            };
+            autoFitPosition: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            renderToBody: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            preventFocus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            scrollToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            scrollToCloseDistance: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{
+            onResize?: (() => any) | undefined;
+            "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
+            onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
+            onShow?: (() => any) | undefined;
+            onHide?: (() => any) | undefined;
+        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
+            disabled: boolean;
+            unmountOnClose: boolean;
+            renderToBody: boolean;
+            position: "top" | "tl" | "tr" | "bottom" | "bl" | "br" | "left" | "lt" | "lb" | "right" | "rt" | "rb";
+            autoFitPosition: boolean;
+            popupVisible: boolean;
+            defaultPopupVisible: boolean;
+            trigger: "hover" | "click" | "focus" | "contextMenu" | ("hover" | "click" | "focus" | "contextMenu")[];
+            popupOffset: number;
+            showArrow: boolean;
+            alignPoint: boolean;
+            popupHoverStay: boolean;
+            blurToClose: boolean;
+            clickToClose: boolean;
+            clickOutsideToClose: boolean;
+            animationName: string;
+            mouseEnterDelay: number;
+            mouseLeaveDelay: number;
+            focusDelay: number;
+            autoFitPopupWidth: boolean;
+            autoFitPopupMinWidth: boolean;
+            autoFixPosition: boolean;
+            updateAtScroll: boolean;
+            autoFitTransformOrigin: boolean;
+            hideEmpty: boolean;
+            preventFocus: boolean;
+            scrollToClose: boolean;
+            scrollToCloseDistance: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        popupVisible: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        defaultPopupVisible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        trigger: {
+            type: PropType<import("..").TriggerEvent | import("..").TriggerEvent[]>;
+            default: string;
+        };
+        position: {
+            type: PropType<import("..").TriggerPosition>;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        popupOffset: {
+            type: NumberConstructor;
+            default: number;
+        };
+        popupTranslate: {
+            type: PropType<import("..").TriggerPopupTranslate>;
+        };
+        showArrow: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        alignPoint: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        popupHoverStay: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        blurToClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        clickToClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        clickOutsideToClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        unmountOnClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        contentClass: {
+            type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+        };
+        contentStyle: {
+            type: PropType<CSSProperties>;
+        };
+        arrowClass: {
+            type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+        };
+        arrowStyle: {
+            type: PropType<CSSProperties>;
+        };
+        popupStyle: {
+            type: PropType<CSSProperties>;
+        };
+        animationName: {
+            type: StringConstructor;
+            default: string;
+        };
+        duration: {
+            type: PropType<number | {
+                enter: number;
+                leave: number;
+            }>;
+        };
+        mouseEnterDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        mouseLeaveDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        focusDelay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        autoFitPopupWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoFitPopupMinWidth: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoFixPosition: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        popupContainer: {
+            type: PropType<string | HTMLElement>;
+        };
+        updateAtScroll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoFitTransformOrigin: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideEmpty: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        openedClass: {
+            type: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
+        };
+        autoFitPosition: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        renderToBody: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        preventFocus: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        scrollToClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        scrollToCloseDistance: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{
+        onResize?: (() => any) | undefined;
+        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
+        onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
+        onShow?: (() => any) | undefined;
+        onHide?: (() => any) | undefined;
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:popupVisible': (visible: boolean) => true;
+        popupVisibleChange: (visible: boolean) => true;
+        show: () => true;
+        hide: () => true;
+        resize: () => true;
+    }, string, {
+        disabled: boolean;
+        unmountOnClose: boolean;
+        renderToBody: boolean;
+        position: "top" | "tl" | "tr" | "bottom" | "bl" | "br" | "left" | "lt" | "lb" | "right" | "rt" | "rb";
+        autoFitPosition: boolean;
+        popupVisible: boolean;
+        defaultPopupVisible: boolean;
+        trigger: "hover" | "click" | "focus" | "contextMenu" | ("hover" | "click" | "focus" | "contextMenu")[];
+        popupOffset: number;
+        showArrow: boolean;
+        alignPoint: boolean;
+        popupHoverStay: boolean;
+        blurToClose: boolean;
+        clickToClose: boolean;
+        clickOutsideToClose: boolean;
+        animationName: string;
+        mouseEnterDelay: number;
+        mouseLeaveDelay: number;
+        focusDelay: number;
+        autoFitPopupWidth: boolean;
+        autoFitPopupMinWidth: boolean;
+        autoFixPosition: boolean;
+        updateAtScroll: boolean;
+        autoFitTransformOrigin: boolean;
+        hideEmpty: boolean;
+        preventFocus: boolean;
+        scrollToClose: boolean;
+        scrollToCloseDistance: number;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+    };
+    SelectView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: PropType<SelectViewValue[]>;
+            required: true;
+        };
+        inputValue: StringConstructor;
+        placeholder: StringConstructor;
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        opened: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: PropType<Size>;
+        };
+        bordered: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowCreate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowSearch: {
+            type: BooleanConstructor;
+            default: (props: Data) => boolean;
+        };
+        maxTagCount: {
+            type: NumberConstructor;
+            default: number;
+        };
+        tagNowrap: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        retainInputValue: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        inputRef: import("vue").ComputedRef<HTMLInputElement>;
+        handleFocus: (ev: FocusEvent) => void;
+        handleBlur: (ev: FocusEvent) => void;
+        render: () => import("vue/jsx-runtime").JSX.Element;
+    }, {}, {}, {
+        focus(): void;
+        blur(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "blur" | "clear" | "remove")[], "focus" | "blur" | "clear" | "remove", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: PropType<SelectViewValue[]>;
+            required: true;
+        };
+        inputValue: StringConstructor;
+        placeholder: StringConstructor;
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        error: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        opened: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: PropType<Size>;
+        };
+        bordered: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowCreate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        allowSearch: {
+            type: BooleanConstructor;
+            default: (props: Data) => boolean;
+        };
+        maxTagCount: {
+            type: NumberConstructor;
+            default: number;
+        };
+        tagNowrap: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        retainInputValue: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        onClear?: ((...args: any[]) => any) | undefined;
+        onRemove?: ((...args: any[]) => any) | undefined;
+    }>, {
+        error: boolean;
+        disabled: boolean;
+        loading: boolean;
+        allowClear: boolean;
+        multiple: boolean;
+        bordered: boolean;
+        maxTagCount: number;
+        retainInputValue: boolean;
+        tagNowrap: boolean;
+        opened: boolean;
+        allowCreate: boolean;
+        allowSearch: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Panel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        treeProps: {
+            type: PropType<Partial<TreeProps>>;
+            default: () => {};
+        };
+        selectedKeys: {
+            type: PropType<TreeNodeKey[]>;
+        };
+        showCheckable: {
+            type: BooleanConstructor;
+        };
+        treeSlots: {
+            type: PropType<import("vue").Slots>;
+            default: () => {};
+        };
+        scrollbar: {
+            type: PropType<boolean | ScrollbarProps>;
+            default: boolean;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        treeProps: {
+            type: PropType<Partial<TreeProps>>;
+            default: () => {};
+        };
+        selectedKeys: {
+            type: PropType<TreeNodeKey[]>;
+        };
+        showCheckable: {
+            type: BooleanConstructor;
+        };
+        treeSlots: {
+            type: PropType<import("vue").Slots>;
+            default: () => {};
+        };
+        scrollbar: {
+            type: PropType<boolean | ScrollbarProps>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onChange?: ((...args: any[]) => any) | undefined;
+    }>, {
+        scrollbar: boolean | ScrollbarProps;
+        treeProps: Partial<TreeProps>;
+        showCheckable: boolean;
+        treeSlots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+    }, {}, {
+        Tree: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: PropType<"mini" | "small" | "medium" | "large">;
+                    default: string;
+                };
+                blockNode: {
+                    type: BooleanConstructor;
+                };
+                defaultExpandAll: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                multiple: {
+                    type: BooleanConstructor;
+                };
+                checkable: {
+                    type: PropType<boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean)>;
+                    default: boolean;
+                };
+                selectable: {
+                    type: PropType<boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean)>;
+                    default: boolean;
+                };
+                checkStrictly: {
+                    type: BooleanConstructor;
+                };
+                checkedStrategy: {
+                    type: PropType<"all" | "parent" | "child">;
+                    default: string;
+                };
+                defaultSelectedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                selectedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                defaultCheckedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                checkedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                defaultExpandedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                expandedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                data: {
+                    type: PropType<TreeNodeData[]>;
+                    default: () => never[];
+                };
+                fieldNames: {
+                    type: PropType<TreeFieldNames>;
+                };
+                showLine: {
+                    type: BooleanConstructor;
+                };
+                loadMore: {
+                    type: PropType<(node: TreeNodeData) => Promise<void>>;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                };
+                allowDrop: {
+                    type: PropType<(options: {
+                        dropNode: TreeNodeData;
+                        dropPosition: -1 | 0 | 1;
+                    }) => boolean>;
+                };
+                filterTreeNode: {
+                    type: PropType<import("../tree/interface").FilterTreeNode>;
+                };
+                searchValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                virtualListProps: {
+                    type: PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
+                };
+                defaultExpandSelected: {
+                    type: BooleanConstructor;
+                };
+                defaultExpandChecked: {
+                    type: BooleanConstructor;
+                };
+                autoExpandParent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                halfCheckedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                onlyCheckLeaf: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                animation: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                actionOnNodeClick: {
+                    type: PropType<"expand">;
+                };
+                disableSelectActionOnly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onDrop?: ((data: {
+                    e: DragEvent;
+                    dragNode: TreeNodeData;
+                    dropNode: TreeNodeData;
+                    dropPosition: number;
+                }) => any) | undefined;
+                onSelect?: ((selectedKeys: (string | number)[], data: {
+                    selected?: boolean;
+                    selectedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    e?: Event;
+                }) => any) | undefined;
+                onCheck?: ((checkedKeys: (string | number)[], data: {
+                    checked?: boolean;
+                    checkedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    halfCheckedKeys: (string | number)[];
+                    halfCheckedNodes: TreeNodeData[];
+                    e?: Event;
+                }) => any) | undefined;
+                "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
+                "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
+                onExpand?: ((expandKeys: (string | number)[], data: {
+                    expanded?: boolean;
+                    expandedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    e?: Event;
+                }) => any) | undefined;
+                onDragStart?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                onDragOver?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                onDragLeave?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                onDragEnd?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
+                "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
+            }>, {
+                classNames: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean);
+                })[]>;
+                visibleTreeNodeList: import("vue").ComputedRef<Node[]>;
+                treeContext: {
+                    treeProps: {
+                        readonly size: "mini" | "small" | "medium" | "large";
+                        readonly data: {
+                            key?: string | number | undefined;
+                            title?: string | undefined;
+                            selectable?: boolean | undefined;
+                            disabled?: boolean | undefined;
+                            disableCheckbox?: boolean | undefined;
+                            checkable?: boolean | undefined;
+                            draggable?: boolean | undefined;
+                            isLeaf?: boolean | undefined;
+                            icon?: (() => import("vue").VNode) | undefined;
+                            switcherIcon?: (() => import("vue").VNode) | undefined;
+                            loadingIcon?: (() => import("vue").VNode) | undefined;
+                            dragIcon?: (() => import("vue").VNode) | undefined;
+                            children?: any[] | undefined;
+                        }[];
+                        readonly draggable: boolean;
+                        readonly multiple: boolean;
+                        readonly checkable: boolean | ((node: TreeNodeData, info: {
+                            level: number;
+                            isLeaf: boolean;
+                        }) => boolean);
+                        readonly checkStrictly: boolean;
+                        readonly animation: boolean;
+                        readonly selectable: boolean | ((node: TreeNodeData, info: {
+                            level: number;
+                            isLeaf: boolean;
+                        }) => boolean);
+                        readonly onlyCheckLeaf: boolean;
+                        readonly blockNode: boolean;
+                        readonly showLine: boolean;
+                        readonly defaultExpandAll: boolean;
+                        readonly checkedStrategy: "all" | "parent" | "child";
+                        readonly searchValue: string;
+                        readonly defaultExpandSelected: boolean;
+                        readonly defaultExpandChecked: boolean;
+                        readonly autoExpandParent: boolean;
+                        readonly disableSelectActionOnly: boolean;
+                        readonly fieldNames: {
+                            key?: string | undefined;
+                            title?: string | undefined;
+                            disabled?: string | undefined;
+                            children?: string | undefined;
+                            isLeaf?: string | undefined;
+                            disableCheckbox?: string | undefined;
+                            checkable?: string | undefined;
+                            icon?: string | undefined;
+                        } | undefined;
+                        readonly virtualListProps: {
+                            height?: number | string | undefined;
+                            threshold?: number | undefined;
+                            isStaticItemHeight?: boolean | undefined;
+                            fixedSize?: boolean | undefined;
+                            estimatedSize?: number | undefined;
+                            buffer?: number | undefined;
+                            data?: unknown[] | undefined;
+                            itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
+                            component?: keyof HTMLElementTagNameMap | undefined;
+                        } | undefined;
+                        readonly loadMore: ((node: TreeNodeData) => Promise<void>) | undefined;
+                        readonly selectedKeys: (string | number)[] | undefined;
+                        readonly defaultSelectedKeys: (string | number)[] | undefined;
+                        readonly expandedKeys: (string | number)[] | undefined;
+                        readonly defaultExpandedKeys: (string | number)[] | undefined;
+                        readonly checkedKeys: (string | number)[] | undefined;
+                        readonly defaultCheckedKeys: (string | number)[] | undefined;
+                        readonly halfCheckedKeys: (string | number)[] | undefined;
+                        readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
+                        readonly allowDrop: ((options: {
+                            dropNode: TreeNodeData;
+                            dropPosition: -1 | 0 | 1;
+                        }) => boolean) | undefined;
+                        readonly actionOnNodeClick: "expand" | undefined;
+                        readonly onDrop: ((data: {
+                            e: DragEvent;
+                            dragNode: TreeNodeData;
+                            dropNode: TreeNodeData;
+                            dropPosition: number;
+                        }) => any) | undefined;
+                        readonly onSelect: ((selectedKeys: (string | number)[], data: {
+                            selected?: boolean;
+                            selectedNodes: TreeNodeData[];
+                            node?: TreeNodeData;
+                            e?: Event;
+                        }) => any) | undefined;
+                        readonly onCheck: ((checkedKeys: (string | number)[], data: {
+                            checked?: boolean;
+                            checkedNodes: TreeNodeData[];
+                            node?: TreeNodeData;
+                            halfCheckedKeys: (string | number)[];
+                            halfCheckedNodes: TreeNodeData[];
+                            e?: Event;
+                        }) => any) | undefined;
+                        readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
+                        readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
+                        readonly onExpand: ((expandKeys: (string | number)[], data: {
+                            expanded?: boolean;
+                            expandedNodes: TreeNodeData[];
+                            node?: TreeNodeData;
+                            e?: Event;
+                        }) => any) | undefined;
+                        readonly onDragStart: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly onDragOver: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly onDragLeave: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly onDragEnd: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
+                        readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
+                    };
+                    switcherIcon: import("vue").Slot<any> | undefined;
+                    loadingIcon: import("vue").Slot<any> | undefined;
+                    dragIcon: import("vue").Slot<any> | undefined;
+                    nodeIcon: import("vue").Slot<any> | undefined;
+                    nodeTitle: import("vue").Slot<any> | undefined;
+                    nodeExtra: import("vue").Slot<any> | undefined;
+                    treeData: {
+                        key: TreeNodeKey;
+                        treeNodeProps: {
+                            selectable: boolean;
+                            disabled: boolean;
+                            disableCheckbox: boolean;
+                            checkable: boolean;
+                            draggable: boolean;
+                            isLeaf: boolean;
+                            isTail: boolean;
+                            blockNode: boolean;
+                            showLine: boolean;
+                            level: number;
+                            lineless: boolean[];
+                            title?: string | undefined;
+                            key?: string | number | undefined;
+                            icon?: (() => import("vue").VNode) | undefined;
+                            switcherIcon?: (() => import("vue").VNode) | undefined;
+                            loadingIcon?: (() => import("vue").VNode) | undefined;
+                            dragIcon?: (() => import("vue").VNode) | undefined;
+                        };
+                        treeNodeData: {
+                            key?: string | number | undefined;
+                            title?: string | undefined;
+                            selectable?: boolean | undefined;
+                            disabled?: boolean | undefined;
+                            disableCheckbox?: boolean | undefined;
+                            checkable?: boolean | undefined;
+                            draggable?: boolean | undefined;
+                            isLeaf?: boolean | undefined;
+                            icon?: (() => import("vue").VNode) | undefined;
+                            switcherIcon?: (() => import("vue").VNode) | undefined;
+                            loadingIcon?: (() => import("vue").VNode) | undefined;
+                            dragIcon?: (() => import("vue").VNode) | undefined;
+                            children?: any[] | undefined;
+                        };
+                        parent?: any | undefined;
+                        parentKey?: TreeNodeKey | undefined;
+                        pathParentKeys: TreeNodeKey[];
+                        children?: any[] | undefined;
+                        selectable: boolean;
+                        disabled: boolean;
+                        disableCheckbox: boolean;
+                        checkable: boolean;
+                        draggable: boolean;
+                        isLeaf: boolean;
+                        isTail: boolean;
+                        blockNode: boolean;
+                        showLine: boolean;
+                        level: number;
+                        lineless: boolean[];
+                        title?: string | undefined;
+                        icon?: (() => import("vue").VNode) | undefined;
+                        switcherIcon?: (() => import("vue").VNode) | undefined;
+                        loadingIcon?: (() => import("vue").VNode) | undefined;
+                        dragIcon?: (() => import("vue").VNode) | undefined;
+                    }[];
+                    flattenTreeData: Node[];
+                    key2TreeNode: import("../tree/interface").Key2TreeNode;
+                    checkedKeys: TreeNodeKey[];
+                    indeterminateKeys: TreeNodeKey[];
+                    selectedKeys: TreeNodeKey[];
+                    expandedKeys: TreeNodeKey[];
+                    loadingKeys: TreeNodeKey[];
+                    currentExpandKeys: TreeNodeKey[];
+                    onLoadMore: ((key: TreeNodeKey) => Promise<void>) | undefined;
+                    filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
+                    onCheck: (checked: boolean, key: TreeNodeKey, e?: Event) => void;
+                    onSelect: (key: TreeNodeKey, e: Event) => void;
+                    onExpand: (expanded: boolean, key: TreeNodeKey, e?: Event) => void;
+                    onExpandEnd: (key: TreeNodeKey) => void;
+                    allowDrop: (key: TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
+                    onDragStart: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDragEnd: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDragOver: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDragLeave: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDrop: (key: TreeNodeKey, dropPosition: number, e: DragEvent) => void;
+                };
+                virtualListRef: import("vue").Ref<any, any>;
+                computedSelectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                computedExpandedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                computedCheckedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                computedIndeterminateKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                getPublicCheckedKeys: (rawCheckedKeys: TreeNodeKey[], rawCheckedStrategy?: "all" | "parent" | "child") => TreeNodeKey[];
+                getNodes: (keys: TreeNodeKey[]) => (TreeNodeData | undefined)[];
+                internalCheckNodes: (keys: TreeNodeKey[], checked: boolean, targetKey?: TreeNodeKey) => void;
+                internalSetCheckedKeys: (keys: TreeNodeKey[]) => void;
+                internalSelectNodes: (keys: TreeNodeKey[], selected: boolean, targetKey?: TreeNodeKey) => void;
+                internalSetSelectedKeys: (keys: TreeNodeKey[]) => void;
+                internalExpandNodes: (keys: TreeNodeKey[], expanded: boolean, targetKey?: TreeNodeKey) => void;
+                internalSetExpandedKeys: (keys: TreeNodeKey[]) => void;
+            }, {}, {}, {
+                toggleCheck(key: TreeNodeKey, e: Event): void;
+                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
+                getSelectedNodes(): (TreeNodeData | undefined)[];
+                getCheckedNodes(options?: {
+                    checkedStrategy?: import("../tree/interface").CheckedStrategy;
+                    includeHalfChecked?: boolean;
+                }): (TreeNodeData | undefined)[];
+                getHalfCheckedNodes(): (TreeNodeData | undefined)[];
+                getExpandedNodes(): (TreeNodeData | undefined)[];
+                checkAll(checked?: boolean): void;
+                checkNode(key: TreeNodeKey | TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
+                selectAll(selected?: boolean): void;
+                selectNode(key: TreeNodeKey | TreeNodeKey[], selected?: boolean): void;
+                expandAll(expanded?: boolean): void;
+                expandNode(key: TreeNodeKey | TreeNodeKey[], expanded?: boolean): void;
+            }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                select: (selectedKeys: (string | number)[], data: {
+                    selected?: boolean;
+                    selectedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    e?: Event;
+                }) => true;
+                'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
+                check: (checkedKeys: (string | number)[], data: {
+                    checked?: boolean;
+                    checkedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    halfCheckedKeys: (string | number)[];
+                    halfCheckedNodes: TreeNodeData[];
+                    e?: Event;
+                }) => true;
+                'update:checkedKeys': (checkedKeys: (string | number)[]) => true;
+                'update:halfCheckedKeys': (halfCheckedKeys: (string | number)[]) => true;
+                expand: (expandKeys: (string | number)[], data: {
+                    expanded?: boolean;
+                    expandedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    e?: Event;
+                }) => true;
+                'update:expandedKeys': (expandKeys: (string | number)[]) => true;
+                dragStart: (ev: DragEvent, node: TreeNodeData) => true;
+                dragEnd: (ev: DragEvent, node: TreeNodeData) => true;
+                dragOver: (ev: DragEvent, node: TreeNodeData) => true;
+                dragLeave: (ev: DragEvent, node: TreeNodeData) => true;
+                drop: (data: {
+                    e: DragEvent;
+                    dragNode: TreeNodeData;
+                    dropNode: TreeNodeData;
+                    dropPosition: number;
+                }) => true;
+            }, import("vue").PublicProps, {
+                size: "mini" | "small" | "medium" | "large";
+                data: TreeNodeData[];
+                draggable: boolean;
+                multiple: boolean;
+                checkable: boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean);
+                checkStrictly: boolean;
+                animation: boolean;
+                selectable: boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean);
+                onlyCheckLeaf: boolean;
+                blockNode: boolean;
+                showLine: boolean;
+                defaultExpandAll: boolean;
+                checkedStrategy: "all" | "parent" | "child";
+                searchValue: string;
+                defaultExpandSelected: boolean;
+                defaultExpandChecked: boolean;
+                autoExpandParent: boolean;
+                disableSelectActionOnly: boolean;
+            }, true, {}, {}, {
+                VirtualList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    height: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                    data: {
+                        type: PropType<Record<string, any>[]>;
+                        default: () => never[];
+                    };
+                    threshold: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    itemKey: {
+                        type: PropType<string | ((item: Record<string, any>) => import("../_components/virtual-list-v2/interface").VirtualItemKey)>;
+                        default: string;
+                    };
+                    fixedSize: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    estimatedSize: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    buffer: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    component: {
+                        type: (StringConstructor | ObjectConstructor)[];
+                        default: string;
+                    };
+                    listAttrs: {
+                        type: ObjectConstructor;
+                    };
+                    contentAttrs: {
+                        type: ObjectConstructor;
+                    };
+                    paddingPosition: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>, {
+                    prefixCls: string;
+                    containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                    contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                    frontPadding: import("vue").ComputedRef<number>;
+                    currentList: import("vue").ComputedRef<Record<string, any>[]>;
+                    behindPadding: import("vue").ComputedRef<number>;
+                    getItemKey: (item: Record<string, any>, index: number) => import("../_components/virtual-list-v2/interface").VirtualItemKey;
+                    onScroll: (ev: Event) => void;
+                    setItemSize: (key: string | number, size: number) => void;
+                    hasItemSize: (key: string | number) => boolean;
+                    start: import("vue").Ref<number, number>;
+                    scrollTo: (options: import("../_components/virtual-list-v2/interface").ScrollOptions) => void;
+                    style: import("vue").ComputedRef<{
+                        height: string;
+                        overflow: string;
+                    }>;
+                    mergedComponent: import("vue").ComputedRef<{
+                        container: string;
+                        list: string;
+                        content: string;
+                    }>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    scroll: (ev: Event) => true;
+                    reachBottom: (ev: Event) => true;
+                }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    height: {
+                        type: (StringConstructor | NumberConstructor)[];
+                        default: number;
+                    };
+                    data: {
+                        type: PropType<Record<string, any>[]>;
+                        default: () => never[];
+                    };
+                    threshold: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    itemKey: {
+                        type: PropType<string | ((item: Record<string, any>) => import("../_components/virtual-list-v2/interface").VirtualItemKey)>;
+                        default: string;
+                    };
+                    fixedSize: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    estimatedSize: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    buffer: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    component: {
+                        type: (StringConstructor | ObjectConstructor)[];
+                        default: string;
+                    };
+                    listAttrs: {
+                        type: ObjectConstructor;
+                    };
+                    contentAttrs: {
+                        type: ObjectConstructor;
+                    };
+                    paddingPosition: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>> & Readonly<{
+                    onScroll?: ((ev: Event) => any) | undefined;
+                    onReachBottom?: ((ev: Event) => any) | undefined;
+                }>, {
+                    data: Record<string, any>[];
+                    height: string | number;
+                    fixedSize: boolean;
+                    estimatedSize: number;
+                    buffer: number;
+                    threshold: number;
+                    itemKey: string | ((item: Record<string, any>) => import("../_components/virtual-list-v2/interface").VirtualItemKey);
+                    component: string | Record<string, any>;
+                    paddingPosition: string;
+                }, {}, {
+                    VirtualListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        hasItemSize: {
+                            type: FunctionConstructor;
+                            required: true;
+                        };
+                        setItemSize: {
+                            type: FunctionConstructor;
+                            required: true;
+                        };
+                    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                        [key: string]: any;
+                    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        hasItemSize: {
+                            type: FunctionConstructor;
+                            required: true;
+                        };
+                        setItemSize: {
+                            type: FunctionConstructor;
+                            required: true;
+                        };
+                    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                TreeNode: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
+                    [x: string]: any;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                size: {
+                    type: PropType<"mini" | "small" | "medium" | "large">;
+                    default: string;
+                };
+                blockNode: {
+                    type: BooleanConstructor;
+                };
+                defaultExpandAll: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                multiple: {
+                    type: BooleanConstructor;
+                };
+                checkable: {
+                    type: PropType<boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean)>;
+                    default: boolean;
+                };
+                selectable: {
+                    type: PropType<boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean)>;
+                    default: boolean;
+                };
+                checkStrictly: {
+                    type: BooleanConstructor;
+                };
+                checkedStrategy: {
+                    type: PropType<"all" | "parent" | "child">;
+                    default: string;
+                };
+                defaultSelectedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                selectedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                defaultCheckedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                checkedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                defaultExpandedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                expandedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                data: {
+                    type: PropType<TreeNodeData[]>;
+                    default: () => never[];
+                };
+                fieldNames: {
+                    type: PropType<TreeFieldNames>;
+                };
+                showLine: {
+                    type: BooleanConstructor;
+                };
+                loadMore: {
+                    type: PropType<(node: TreeNodeData) => Promise<void>>;
+                };
+                draggable: {
+                    type: BooleanConstructor;
+                };
+                allowDrop: {
+                    type: PropType<(options: {
+                        dropNode: TreeNodeData;
+                        dropPosition: -1 | 0 | 1;
+                    }) => boolean>;
+                };
+                filterTreeNode: {
+                    type: PropType<import("../tree/interface").FilterTreeNode>;
+                };
+                searchValue: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                virtualListProps: {
+                    type: PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
+                };
+                defaultExpandSelected: {
+                    type: BooleanConstructor;
+                };
+                defaultExpandChecked: {
+                    type: BooleanConstructor;
+                };
+                autoExpandParent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                halfCheckedKeys: {
+                    type: PropType<Array<string | number>>;
+                };
+                onlyCheckLeaf: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                animation: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                actionOnNodeClick: {
+                    type: PropType<"expand">;
+                };
+                disableSelectActionOnly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onDrop?: ((data: {
+                    e: DragEvent;
+                    dragNode: TreeNodeData;
+                    dropNode: TreeNodeData;
+                    dropPosition: number;
+                }) => any) | undefined;
+                onSelect?: ((selectedKeys: (string | number)[], data: {
+                    selected?: boolean;
+                    selectedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    e?: Event;
+                }) => any) | undefined;
+                onCheck?: ((checkedKeys: (string | number)[], data: {
+                    checked?: boolean;
+                    checkedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    halfCheckedKeys: (string | number)[];
+                    halfCheckedNodes: TreeNodeData[];
+                    e?: Event;
+                }) => any) | undefined;
+                "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
+                "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
+                onExpand?: ((expandKeys: (string | number)[], data: {
+                    expanded?: boolean;
+                    expandedNodes: TreeNodeData[];
+                    node?: TreeNodeData;
+                    e?: Event;
+                }) => any) | undefined;
+                onDragStart?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                onDragOver?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                onDragLeave?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                onDragEnd?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
+                "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
+            }>, {
+                classNames: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean);
+                })[]>;
+                visibleTreeNodeList: import("vue").ComputedRef<Node[]>;
+                treeContext: {
+                    treeProps: {
+                        readonly size: "mini" | "small" | "medium" | "large";
+                        readonly data: {
+                            key?: string | number | undefined;
+                            title?: string | undefined;
+                            selectable?: boolean | undefined;
+                            disabled?: boolean | undefined;
+                            disableCheckbox?: boolean | undefined;
+                            checkable?: boolean | undefined;
+                            draggable?: boolean | undefined;
+                            isLeaf?: boolean | undefined;
+                            icon?: (() => import("vue").VNode) | undefined;
+                            switcherIcon?: (() => import("vue").VNode) | undefined;
+                            loadingIcon?: (() => import("vue").VNode) | undefined;
+                            dragIcon?: (() => import("vue").VNode) | undefined;
+                            children?: any[] | undefined;
+                        }[];
+                        readonly draggable: boolean;
+                        readonly multiple: boolean;
+                        readonly checkable: boolean | ((node: TreeNodeData, info: {
+                            level: number;
+                            isLeaf: boolean;
+                        }) => boolean);
+                        readonly checkStrictly: boolean;
+                        readonly animation: boolean;
+                        readonly selectable: boolean | ((node: TreeNodeData, info: {
+                            level: number;
+                            isLeaf: boolean;
+                        }) => boolean);
+                        readonly onlyCheckLeaf: boolean;
+                        readonly blockNode: boolean;
+                        readonly showLine: boolean;
+                        readonly defaultExpandAll: boolean;
+                        readonly checkedStrategy: "all" | "parent" | "child";
+                        readonly searchValue: string;
+                        readonly defaultExpandSelected: boolean;
+                        readonly defaultExpandChecked: boolean;
+                        readonly autoExpandParent: boolean;
+                        readonly disableSelectActionOnly: boolean;
+                        readonly fieldNames: {
+                            key?: string | undefined;
+                            title?: string | undefined;
+                            disabled?: string | undefined;
+                            children?: string | undefined;
+                            isLeaf?: string | undefined;
+                            disableCheckbox?: string | undefined;
+                            checkable?: string | undefined;
+                            icon?: string | undefined;
+                        } | undefined;
+                        readonly virtualListProps: {
+                            height?: number | string | undefined;
+                            threshold?: number | undefined;
+                            isStaticItemHeight?: boolean | undefined;
+                            fixedSize?: boolean | undefined;
+                            estimatedSize?: number | undefined;
+                            buffer?: number | undefined;
+                            data?: unknown[] | undefined;
+                            itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
+                            component?: keyof HTMLElementTagNameMap | undefined;
+                        } | undefined;
+                        readonly loadMore: ((node: TreeNodeData) => Promise<void>) | undefined;
+                        readonly selectedKeys: (string | number)[] | undefined;
+                        readonly defaultSelectedKeys: (string | number)[] | undefined;
+                        readonly expandedKeys: (string | number)[] | undefined;
+                        readonly defaultExpandedKeys: (string | number)[] | undefined;
+                        readonly checkedKeys: (string | number)[] | undefined;
+                        readonly defaultCheckedKeys: (string | number)[] | undefined;
+                        readonly halfCheckedKeys: (string | number)[] | undefined;
+                        readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
+                        readonly allowDrop: ((options: {
+                            dropNode: TreeNodeData;
+                            dropPosition: -1 | 0 | 1;
+                        }) => boolean) | undefined;
+                        readonly actionOnNodeClick: "expand" | undefined;
+                        readonly onDrop: ((data: {
+                            e: DragEvent;
+                            dragNode: TreeNodeData;
+                            dropNode: TreeNodeData;
+                            dropPosition: number;
+                        }) => any) | undefined;
+                        readonly onSelect: ((selectedKeys: (string | number)[], data: {
+                            selected?: boolean;
+                            selectedNodes: TreeNodeData[];
+                            node?: TreeNodeData;
+                            e?: Event;
+                        }) => any) | undefined;
+                        readonly onCheck: ((checkedKeys: (string | number)[], data: {
+                            checked?: boolean;
+                            checkedNodes: TreeNodeData[];
+                            node?: TreeNodeData;
+                            halfCheckedKeys: (string | number)[];
+                            halfCheckedNodes: TreeNodeData[];
+                            e?: Event;
+                        }) => any) | undefined;
+                        readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
+                        readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
+                        readonly onExpand: ((expandKeys: (string | number)[], data: {
+                            expanded?: boolean;
+                            expandedNodes: TreeNodeData[];
+                            node?: TreeNodeData;
+                            e?: Event;
+                        }) => any) | undefined;
+                        readonly onDragStart: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly onDragOver: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly onDragLeave: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly onDragEnd: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                        readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
+                        readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
+                    };
+                    switcherIcon: import("vue").Slot<any> | undefined;
+                    loadingIcon: import("vue").Slot<any> | undefined;
+                    dragIcon: import("vue").Slot<any> | undefined;
+                    nodeIcon: import("vue").Slot<any> | undefined;
+                    nodeTitle: import("vue").Slot<any> | undefined;
+                    nodeExtra: import("vue").Slot<any> | undefined;
+                    treeData: {
+                        key: TreeNodeKey;
+                        treeNodeProps: {
+                            selectable: boolean;
+                            disabled: boolean;
+                            disableCheckbox: boolean;
+                            checkable: boolean;
+                            draggable: boolean;
+                            isLeaf: boolean;
+                            isTail: boolean;
+                            blockNode: boolean;
+                            showLine: boolean;
+                            level: number;
+                            lineless: boolean[];
+                            title?: string | undefined;
+                            key?: string | number | undefined;
+                            icon?: (() => import("vue").VNode) | undefined;
+                            switcherIcon?: (() => import("vue").VNode) | undefined;
+                            loadingIcon?: (() => import("vue").VNode) | undefined;
+                            dragIcon?: (() => import("vue").VNode) | undefined;
+                        };
+                        treeNodeData: {
+                            key?: string | number | undefined;
+                            title?: string | undefined;
+                            selectable?: boolean | undefined;
+                            disabled?: boolean | undefined;
+                            disableCheckbox?: boolean | undefined;
+                            checkable?: boolean | undefined;
+                            draggable?: boolean | undefined;
+                            isLeaf?: boolean | undefined;
+                            icon?: (() => import("vue").VNode) | undefined;
+                            switcherIcon?: (() => import("vue").VNode) | undefined;
+                            loadingIcon?: (() => import("vue").VNode) | undefined;
+                            dragIcon?: (() => import("vue").VNode) | undefined;
+                            children?: any[] | undefined;
+                        };
+                        parent?: any | undefined;
+                        parentKey?: TreeNodeKey | undefined;
+                        pathParentKeys: TreeNodeKey[];
+                        children?: any[] | undefined;
+                        selectable: boolean;
+                        disabled: boolean;
+                        disableCheckbox: boolean;
+                        checkable: boolean;
+                        draggable: boolean;
+                        isLeaf: boolean;
+                        isTail: boolean;
+                        blockNode: boolean;
+                        showLine: boolean;
+                        level: number;
+                        lineless: boolean[];
+                        title?: string | undefined;
+                        icon?: (() => import("vue").VNode) | undefined;
+                        switcherIcon?: (() => import("vue").VNode) | undefined;
+                        loadingIcon?: (() => import("vue").VNode) | undefined;
+                        dragIcon?: (() => import("vue").VNode) | undefined;
+                    }[];
+                    flattenTreeData: Node[];
+                    key2TreeNode: import("../tree/interface").Key2TreeNode;
+                    checkedKeys: TreeNodeKey[];
+                    indeterminateKeys: TreeNodeKey[];
+                    selectedKeys: TreeNodeKey[];
+                    expandedKeys: TreeNodeKey[];
+                    loadingKeys: TreeNodeKey[];
+                    currentExpandKeys: TreeNodeKey[];
+                    onLoadMore: ((key: TreeNodeKey) => Promise<void>) | undefined;
+                    filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
+                    onCheck: (checked: boolean, key: TreeNodeKey, e?: Event) => void;
+                    onSelect: (key: TreeNodeKey, e: Event) => void;
+                    onExpand: (expanded: boolean, key: TreeNodeKey, e?: Event) => void;
+                    onExpandEnd: (key: TreeNodeKey) => void;
+                    allowDrop: (key: TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
+                    onDragStart: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDragEnd: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDragOver: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDragLeave: (key: TreeNodeKey, e: DragEvent) => void;
+                    onDrop: (key: TreeNodeKey, dropPosition: number, e: DragEvent) => void;
+                };
+                virtualListRef: import("vue").Ref<any, any>;
+                computedSelectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                computedExpandedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                computedCheckedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                computedIndeterminateKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+                getPublicCheckedKeys: (rawCheckedKeys: TreeNodeKey[], rawCheckedStrategy?: "all" | "parent" | "child") => TreeNodeKey[];
+                getNodes: (keys: TreeNodeKey[]) => (TreeNodeData | undefined)[];
+                internalCheckNodes: (keys: TreeNodeKey[], checked: boolean, targetKey?: TreeNodeKey) => void;
+                internalSetCheckedKeys: (keys: TreeNodeKey[]) => void;
+                internalSelectNodes: (keys: TreeNodeKey[], selected: boolean, targetKey?: TreeNodeKey) => void;
+                internalSetSelectedKeys: (keys: TreeNodeKey[]) => void;
+                internalExpandNodes: (keys: TreeNodeKey[], expanded: boolean, targetKey?: TreeNodeKey) => void;
+                internalSetExpandedKeys: (keys: TreeNodeKey[]) => void;
+            }, {}, {}, {
+                toggleCheck(key: TreeNodeKey, e: Event): void;
+                scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
+                getSelectedNodes(): (TreeNodeData | undefined)[];
+                getCheckedNodes(options?: {
+                    checkedStrategy?: import("../tree/interface").CheckedStrategy;
+                    includeHalfChecked?: boolean;
+                }): (TreeNodeData | undefined)[];
+                getHalfCheckedNodes(): (TreeNodeData | undefined)[];
+                getExpandedNodes(): (TreeNodeData | undefined)[];
+                checkAll(checked?: boolean): void;
+                checkNode(key: TreeNodeKey | TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
+                selectAll(selected?: boolean): void;
+                selectNode(key: TreeNodeKey | TreeNodeKey[], selected?: boolean): void;
+                expandAll(expanded?: boolean): void;
+                expandNode(key: TreeNodeKey | TreeNodeKey[], expanded?: boolean): void;
+            }, {
+                size: "mini" | "small" | "medium" | "large";
+                data: TreeNodeData[];
+                draggable: boolean;
+                multiple: boolean;
+                checkable: boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean);
+                checkStrictly: boolean;
+                animation: boolean;
+                selectable: boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean);
+                onlyCheckLeaf: boolean;
+                blockNode: boolean;
+                showLine: boolean;
+                defaultExpandAll: boolean;
+                checkedStrategy: "all" | "parent" | "child";
+                searchValue: string;
+                defaultExpandSelected: boolean;
+                defaultExpandChecked: boolean;
+                autoExpandParent: boolean;
+                disableSelectActionOnly: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            size: {
+                type: PropType<"mini" | "small" | "medium" | "large">;
+                default: string;
+            };
+            blockNode: {
+                type: BooleanConstructor;
+            };
+            defaultExpandAll: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+            };
+            checkable: {
+                type: PropType<boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean)>;
+                default: boolean;
+            };
+            selectable: {
+                type: PropType<boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean)>;
+                default: boolean;
+            };
+            checkStrictly: {
+                type: BooleanConstructor;
+            };
+            checkedStrategy: {
+                type: PropType<"all" | "parent" | "child">;
+                default: string;
+            };
+            defaultSelectedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            selectedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            defaultCheckedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            checkedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            defaultExpandedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            expandedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            data: {
+                type: PropType<TreeNodeData[]>;
+                default: () => never[];
+            };
+            fieldNames: {
+                type: PropType<TreeFieldNames>;
+            };
+            showLine: {
+                type: BooleanConstructor;
+            };
+            loadMore: {
+                type: PropType<(node: TreeNodeData) => Promise<void>>;
+            };
+            draggable: {
+                type: BooleanConstructor;
+            };
+            allowDrop: {
+                type: PropType<(options: {
+                    dropNode: TreeNodeData;
+                    dropPosition: -1 | 0 | 1;
+                }) => boolean>;
+            };
+            filterTreeNode: {
+                type: PropType<import("../tree/interface").FilterTreeNode>;
+            };
+            searchValue: {
+                type: StringConstructor;
+                default: string;
+            };
+            virtualListProps: {
+                type: PropType<import("../_components/virtual-list-v2/interface").VirtualListProps>;
+            };
+            defaultExpandSelected: {
+                type: BooleanConstructor;
+            };
+            defaultExpandChecked: {
+                type: BooleanConstructor;
+            };
+            autoExpandParent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            halfCheckedKeys: {
+                type: PropType<Array<string | number>>;
+            };
+            onlyCheckLeaf: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            animation: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            actionOnNodeClick: {
+                type: PropType<"expand">;
+            };
+            disableSelectActionOnly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onDrop?: ((data: {
+                e: DragEvent;
+                dragNode: TreeNodeData;
+                dropNode: TreeNodeData;
+                dropPosition: number;
+            }) => any) | undefined;
+            onSelect?: ((selectedKeys: (string | number)[], data: {
+                selected?: boolean;
+                selectedNodes: TreeNodeData[];
+                node?: TreeNodeData;
+                e?: Event;
+            }) => any) | undefined;
+            onCheck?: ((checkedKeys: (string | number)[], data: {
+                checked?: boolean;
+                checkedNodes: TreeNodeData[];
+                node?: TreeNodeData;
+                halfCheckedKeys: (string | number)[];
+                halfCheckedNodes: TreeNodeData[];
+                e?: Event;
+            }) => any) | undefined;
+            "onUpdate:selectedKeys"?: ((selectedKeys: (string | number)[]) => any) | undefined;
+            "onUpdate:expandedKeys"?: ((expandKeys: (string | number)[]) => any) | undefined;
+            onExpand?: ((expandKeys: (string | number)[], data: {
+                expanded?: boolean;
+                expandedNodes: TreeNodeData[];
+                node?: TreeNodeData;
+                e?: Event;
+            }) => any) | undefined;
+            onDragStart?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+            onDragOver?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+            onDragLeave?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+            onDragEnd?: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+            "onUpdate:checkedKeys"?: ((checkedKeys: (string | number)[]) => any) | undefined;
+            "onUpdate:halfCheckedKeys"?: ((halfCheckedKeys: (string | number)[]) => any) | undefined;
+        }>, {
+            classNames: import("vue").ComputedRef<(string | {
+                [x: string]: boolean | ((node: TreeNodeData, info: {
+                    level: number;
+                    isLeaf: boolean;
+                }) => boolean);
+            })[]>;
+            visibleTreeNodeList: import("vue").ComputedRef<Node[]>;
+            treeContext: {
+                treeProps: {
+                    readonly size: "mini" | "small" | "medium" | "large";
+                    readonly data: {
+                        key?: string | number | undefined;
+                        title?: string | undefined;
+                        selectable?: boolean | undefined;
+                        disabled?: boolean | undefined;
+                        disableCheckbox?: boolean | undefined;
+                        checkable?: boolean | undefined;
+                        draggable?: boolean | undefined;
+                        isLeaf?: boolean | undefined;
+                        icon?: (() => import("vue").VNode) | undefined;
+                        switcherIcon?: (() => import("vue").VNode) | undefined;
+                        loadingIcon?: (() => import("vue").VNode) | undefined;
+                        dragIcon?: (() => import("vue").VNode) | undefined;
+                        children?: any[] | undefined;
+                    }[];
+                    readonly draggable: boolean;
+                    readonly multiple: boolean;
+                    readonly checkable: boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean);
+                    readonly checkStrictly: boolean;
+                    readonly animation: boolean;
+                    readonly selectable: boolean | ((node: TreeNodeData, info: {
+                        level: number;
+                        isLeaf: boolean;
+                    }) => boolean);
+                    readonly onlyCheckLeaf: boolean;
+                    readonly blockNode: boolean;
+                    readonly showLine: boolean;
+                    readonly defaultExpandAll: boolean;
+                    readonly checkedStrategy: "all" | "parent" | "child";
+                    readonly searchValue: string;
+                    readonly defaultExpandSelected: boolean;
+                    readonly defaultExpandChecked: boolean;
+                    readonly autoExpandParent: boolean;
+                    readonly disableSelectActionOnly: boolean;
+                    readonly fieldNames: {
+                        key?: string | undefined;
+                        title?: string | undefined;
+                        disabled?: string | undefined;
+                        children?: string | undefined;
+                        isLeaf?: string | undefined;
+                        disableCheckbox?: string | undefined;
+                        checkable?: string | undefined;
+                        icon?: string | undefined;
+                    } | undefined;
+                    readonly virtualListProps: {
+                        height?: number | string | undefined;
+                        threshold?: number | undefined;
+                        isStaticItemHeight?: boolean | undefined;
+                        fixedSize?: boolean | undefined;
+                        estimatedSize?: number | undefined;
+                        buffer?: number | undefined;
+                        data?: unknown[] | undefined;
+                        itemKey?: string | ((item: unknown) => import("../_components/virtual-list-v2/interface").VirtualItemKey) | undefined;
+                        component?: keyof HTMLElementTagNameMap | undefined;
+                    } | undefined;
+                    readonly loadMore: ((node: TreeNodeData) => Promise<void>) | undefined;
+                    readonly selectedKeys: (string | number)[] | undefined;
+                    readonly defaultSelectedKeys: (string | number)[] | undefined;
+                    readonly expandedKeys: (string | number)[] | undefined;
+                    readonly defaultExpandedKeys: (string | number)[] | undefined;
+                    readonly checkedKeys: (string | number)[] | undefined;
+                    readonly defaultCheckedKeys: (string | number)[] | undefined;
+                    readonly halfCheckedKeys: (string | number)[] | undefined;
+                    readonly filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
+                    readonly allowDrop: ((options: {
+                        dropNode: TreeNodeData;
+                        dropPosition: -1 | 0 | 1;
+                    }) => boolean) | undefined;
+                    readonly actionOnNodeClick: "expand" | undefined;
+                    readonly onDrop: ((data: {
+                        e: DragEvent;
+                        dragNode: TreeNodeData;
+                        dropNode: TreeNodeData;
+                        dropPosition: number;
+                    }) => any) | undefined;
+                    readonly onSelect: ((selectedKeys: (string | number)[], data: {
+                        selected?: boolean;
+                        selectedNodes: TreeNodeData[];
+                        node?: TreeNodeData;
+                        e?: Event;
+                    }) => any) | undefined;
+                    readonly onCheck: ((checkedKeys: (string | number)[], data: {
+                        checked?: boolean;
+                        checkedNodes: TreeNodeData[];
+                        node?: TreeNodeData;
+                        halfCheckedKeys: (string | number)[];
+                        halfCheckedNodes: TreeNodeData[];
+                        e?: Event;
+                    }) => any) | undefined;
+                    readonly "onUpdate:selectedKeys": ((selectedKeys: (string | number)[]) => any) | undefined;
+                    readonly "onUpdate:expandedKeys": ((expandKeys: (string | number)[]) => any) | undefined;
+                    readonly onExpand: ((expandKeys: (string | number)[], data: {
+                        expanded?: boolean;
+                        expandedNodes: TreeNodeData[];
+                        node?: TreeNodeData;
+                        e?: Event;
+                    }) => any) | undefined;
+                    readonly onDragStart: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                    readonly onDragOver: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                    readonly onDragLeave: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                    readonly onDragEnd: ((ev: DragEvent, node: TreeNodeData) => any) | undefined;
+                    readonly "onUpdate:checkedKeys": ((checkedKeys: (string | number)[]) => any) | undefined;
+                    readonly "onUpdate:halfCheckedKeys": ((halfCheckedKeys: (string | number)[]) => any) | undefined;
+                };
+                switcherIcon: import("vue").Slot<any> | undefined;
+                loadingIcon: import("vue").Slot<any> | undefined;
+                dragIcon: import("vue").Slot<any> | undefined;
+                nodeIcon: import("vue").Slot<any> | undefined;
+                nodeTitle: import("vue").Slot<any> | undefined;
+                nodeExtra: import("vue").Slot<any> | undefined;
+                treeData: {
+                    key: TreeNodeKey;
+                    treeNodeProps: {
+                        selectable: boolean;
+                        disabled: boolean;
+                        disableCheckbox: boolean;
+                        checkable: boolean;
+                        draggable: boolean;
+                        isLeaf: boolean;
+                        isTail: boolean;
+                        blockNode: boolean;
+                        showLine: boolean;
+                        level: number;
+                        lineless: boolean[];
+                        title?: string | undefined;
+                        key?: string | number | undefined;
+                        icon?: (() => import("vue").VNode) | undefined;
+                        switcherIcon?: (() => import("vue").VNode) | undefined;
+                        loadingIcon?: (() => import("vue").VNode) | undefined;
+                        dragIcon?: (() => import("vue").VNode) | undefined;
+                    };
+                    treeNodeData: {
+                        key?: string | number | undefined;
+                        title?: string | undefined;
+                        selectable?: boolean | undefined;
+                        disabled?: boolean | undefined;
+                        disableCheckbox?: boolean | undefined;
+                        checkable?: boolean | undefined;
+                        draggable?: boolean | undefined;
+                        isLeaf?: boolean | undefined;
+                        icon?: (() => import("vue").VNode) | undefined;
+                        switcherIcon?: (() => import("vue").VNode) | undefined;
+                        loadingIcon?: (() => import("vue").VNode) | undefined;
+                        dragIcon?: (() => import("vue").VNode) | undefined;
+                        children?: any[] | undefined;
+                    };
+                    parent?: any | undefined;
+                    parentKey?: TreeNodeKey | undefined;
+                    pathParentKeys: TreeNodeKey[];
+                    children?: any[] | undefined;
+                    selectable: boolean;
+                    disabled: boolean;
+                    disableCheckbox: boolean;
+                    checkable: boolean;
+                    draggable: boolean;
+                    isLeaf: boolean;
+                    isTail: boolean;
+                    blockNode: boolean;
+                    showLine: boolean;
+                    level: number;
+                    lineless: boolean[];
+                    title?: string | undefined;
+                    icon?: (() => import("vue").VNode) | undefined;
+                    switcherIcon?: (() => import("vue").VNode) | undefined;
+                    loadingIcon?: (() => import("vue").VNode) | undefined;
+                    dragIcon?: (() => import("vue").VNode) | undefined;
+                }[];
+                flattenTreeData: Node[];
+                key2TreeNode: import("../tree/interface").Key2TreeNode;
+                checkedKeys: TreeNodeKey[];
+                indeterminateKeys: TreeNodeKey[];
+                selectedKeys: TreeNodeKey[];
+                expandedKeys: TreeNodeKey[];
+                loadingKeys: TreeNodeKey[];
+                currentExpandKeys: TreeNodeKey[];
+                onLoadMore: ((key: TreeNodeKey) => Promise<void>) | undefined;
+                filterTreeNode: import("../tree/interface").FilterTreeNode | undefined;
+                onCheck: (checked: boolean, key: TreeNodeKey, e?: Event) => void;
+                onSelect: (key: TreeNodeKey, e: Event) => void;
+                onExpand: (expanded: boolean, key: TreeNodeKey, e?: Event) => void;
+                onExpandEnd: (key: TreeNodeKey) => void;
+                allowDrop: (key: TreeNodeKey, dropPosition: import("../tree/interface").DropPosition) => boolean;
+                onDragStart: (key: TreeNodeKey, e: DragEvent) => void;
+                onDragEnd: (key: TreeNodeKey, e: DragEvent) => void;
+                onDragOver: (key: TreeNodeKey, e: DragEvent) => void;
+                onDragLeave: (key: TreeNodeKey, e: DragEvent) => void;
+                onDrop: (key: TreeNodeKey, dropPosition: number, e: DragEvent) => void;
+            };
+            virtualListRef: import("vue").Ref<any, any>;
+            computedSelectedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+            computedExpandedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+            computedCheckedKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+            computedIndeterminateKeys: import("vue").ComputedRef<TreeNodeKey[]>;
+            getPublicCheckedKeys: (rawCheckedKeys: TreeNodeKey[], rawCheckedStrategy?: "all" | "parent" | "child") => TreeNodeKey[];
+            getNodes: (keys: TreeNodeKey[]) => (TreeNodeData | undefined)[];
+            internalCheckNodes: (keys: TreeNodeKey[], checked: boolean, targetKey?: TreeNodeKey) => void;
+            internalSetCheckedKeys: (keys: TreeNodeKey[]) => void;
+            internalSelectNodes: (keys: TreeNodeKey[], selected: boolean, targetKey?: TreeNodeKey) => void;
+            internalSetSelectedKeys: (keys: TreeNodeKey[]) => void;
+            internalExpandNodes: (keys: TreeNodeKey[], expanded: boolean, targetKey?: TreeNodeKey) => void;
+            internalSetExpandedKeys: (keys: TreeNodeKey[]) => void;
+        }, {}, {}, {
+            toggleCheck(key: TreeNodeKey, e: Event): void;
+            scrollIntoView(options: import("../_components/virtual-list-v2/interface").ScrollIntoViewOptions): void;
+            getSelectedNodes(): (TreeNodeData | undefined)[];
+            getCheckedNodes(options?: {
+                checkedStrategy?: import("../tree/interface").CheckedStrategy;
+                includeHalfChecked?: boolean;
+            }): (TreeNodeData | undefined)[];
+            getHalfCheckedNodes(): (TreeNodeData | undefined)[];
+            getExpandedNodes(): (TreeNodeData | undefined)[];
+            checkAll(checked?: boolean): void;
+            checkNode(key: TreeNodeKey | TreeNodeKey[], checked?: boolean, onlyCheckLeaf?: boolean): void;
+            selectAll(selected?: boolean): void;
+            selectNode(key: TreeNodeKey | TreeNodeKey[], selected?: boolean): void;
+            expandAll(expanded?: boolean): void;
+            expandNode(key: TreeNodeKey | TreeNodeKey[], expanded?: boolean): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            select: (selectedKeys: (string | number)[], data: {
+                selected?: boolean;
+                selectedNodes: TreeNodeData[];
+                node?: TreeNodeData;
+                e?: Event;
+            }) => true;
+            'update:selectedKeys': (selectedKeys: (string | number)[]) => true;
+            check: (checkedKeys: (string | number)[], data: {
+                checked?: boolean;
+                checkedNodes: TreeNodeData[];
+                node?: TreeNodeData;
+                halfCheckedKeys: (string | number)[];
+                halfCheckedNodes: TreeNodeData[];
+                e?: Event;
+            }) => true;
+            'update:checkedKeys': (checkedKeys: (string | number)[]) => true;
+            'update:halfCheckedKeys': (halfCheckedKeys: (string | number)[]) => true;
+            expand: (expandKeys: (string | number)[], data: {
+                expanded?: boolean;
+                expandedNodes: TreeNodeData[];
+                node?: TreeNodeData;
+                e?: Event;
+            }) => true;
+            'update:expandedKeys': (expandKeys: (string | number)[]) => true;
+            dragStart: (ev: DragEvent, node: TreeNodeData) => true;
+            dragEnd: (ev: DragEvent, node: TreeNodeData) => true;
+            dragOver: (ev: DragEvent, node: TreeNodeData) => true;
+            dragLeave: (ev: DragEvent, node: TreeNodeData) => true;
+            drop: (data: {
+                e: DragEvent;
+                dragNode: TreeNodeData;
+                dropNode: TreeNodeData;
+                dropPosition: number;
+            }) => true;
+        }, string, {
+            size: "mini" | "small" | "medium" | "large";
+            data: TreeNodeData[];
+            draggable: boolean;
+            multiple: boolean;
+            checkable: boolean | ((node: TreeNodeData, info: {
+                level: number;
+                isLeaf: boolean;
+            }) => boolean);
+            checkStrictly: boolean;
+            animation: boolean;
+            selectable: boolean | ((node: TreeNodeData, info: {
+                level: number;
+                isLeaf: boolean;
+            }) => boolean);
+            onlyCheckLeaf: boolean;
+            blockNode: boolean;
+            showLine: boolean;
+            defaultExpandAll: boolean;
+            checkedStrategy: "all" | "parent" | "child";
+            searchValue: string;
+            defaultExpandSelected: boolean;
+            defaultExpandChecked: boolean;
+            autoExpandParent: boolean;
+            disableSelectActionOnly: boolean;
+        }, {}, string, {}, {
+            VirtualList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                height: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: number;
+                };
+                data: {
+                    type: PropType<Record<string, any>[]>;
+                    default: () => never[];
+                };
+                threshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                itemKey: {
+                    type: PropType<string | ((item: Record<string, any>) => import("../_components/virtual-list-v2/interface").VirtualItemKey)>;
+                    default: string;
+                };
+                fixedSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                estimatedSize: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                buffer: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                component: {
+                    type: (StringConstructor | ObjectConstructor)[];
+                    default: string;
+                };
+                listAttrs: {
+                    type: ObjectConstructor;
+                };
+                contentAttrs: {
+                    type: ObjectConstructor;
+                };
+                paddingPosition: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                prefixCls: string;
+                containerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                frontPadding: import("vue").ComputedRef<number>;
+                currentList: import("vue").ComputedRef<Record<string, any>[]>;
+                behindPadding: import("vue").ComputedRef<number>;
+                getItemKey: (item: Record<string, any>, index: number) => import("../_components/virtual-list-v2/interface").VirtualItemKey;
+                onScroll: (ev: Event) => void;
+                setItemSize: (key: string | number, size: number) => void;
+                hasItemSize: (key: string | number) => boolean;
+                start: import("vue").Ref<number, number>;
+                scrollTo: (options: import("../_components/virtual-list-v2/interface").ScrollOptions) => void;
+                style: import("vue").ComputedRef<{
+                    height: string;
+                    overflow: string;
+                }>;
+                mergedComponent: import("vue").ComputedRef<{
+                    container: string;
+                    list: string;
+                    content: string;
+                }>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                scroll: (ev: Event) => true;
+                reachBottom: (ev: Event) => true;
+            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                height: {
+                    type: (StringConstructor | NumberConstructor)[];
+                    default: number;
+                };
+                data: {
+                    type: PropType<Record<string, any>[]>;
+                    default: () => never[];
+                };
+                threshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                itemKey: {
+                    type: PropType<string | ((item: Record<string, any>) => import("../_components/virtual-list-v2/interface").VirtualItemKey)>;
+                    default: string;
+                };
+                fixedSize: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                estimatedSize: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                buffer: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                component: {
+                    type: (StringConstructor | ObjectConstructor)[];
+                    default: string;
+                };
+                listAttrs: {
+                    type: ObjectConstructor;
+                };
+                contentAttrs: {
+                    type: ObjectConstructor;
+                };
+                paddingPosition: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                onScroll?: ((ev: Event) => any) | undefined;
+                onReachBottom?: ((ev: Event) => any) | undefined;
+            }>, {
+                data: Record<string, any>[];
+                height: string | number;
+                fixedSize: boolean;
+                estimatedSize: number;
+                buffer: number;
+                threshold: number;
+                itemKey: string | ((item: Record<string, any>) => import("../_components/virtual-list-v2/interface").VirtualItemKey);
+                component: string | Record<string, any>;
+                paddingPosition: string;
+            }, {}, {
+                VirtualListItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    hasItemSize: {
+                        type: FunctionConstructor;
+                        required: true;
+                    };
+                    setItemSize: {
+                        type: FunctionConstructor;
+                        required: true;
+                    };
+                }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                    [key: string]: any;
+                }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    hasItemSize: {
+                        type: FunctionConstructor;
+                        required: true;
+                    };
+                    setItemSize: {
+                        type: FunctionConstructor;
+                        required: true;
+                    };
+                }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            TreeNode: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
+                [x: string]: any;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+        };
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Empty: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            description: StringConstructor;
+            imgSrc: StringConstructor;
+            inConfigProvider: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            inConfigProvider: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            description: StringConstructor;
+            imgSrc: StringConstructor;
+            inConfigProvider: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
+            inConfigProvider: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        description: StringConstructor;
+        imgSrc: StringConstructor;
+        inConfigProvider: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        inConfigProvider: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+    };
+    Spin: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            size: {
+                type: NumberConstructor;
+            };
+            loading: BooleanConstructor;
+            dot: BooleanConstructor;
+            tip: StringConstructor;
+            hideIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            loading: boolean;
+            dot: boolean;
+            hideIcon: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            size: {
+                type: NumberConstructor;
+            };
+            loading: BooleanConstructor;
+            dot: BooleanConstructor;
+            tip: StringConstructor;
+            hideIcon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
+            loading: boolean;
+            dot: boolean;
+            hideIcon: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        size: {
+            type: NumberConstructor;
+        };
+        loading: BooleanConstructor;
+        dot: BooleanConstructor;
+        tip: StringConstructor;
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        loading: boolean;
+        dot: boolean;
+        hideIcon: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install: (app: import("vue").App, options?: import("../_utils/types").SDOptions) => void;
+    };
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;