@fangzhongya/fang-ui 0.0.30 → 0.0.31

package/dist/components/user-select/src/index.d.ts

@@ -0,0 +1,2509 @@
+import { ModelValue, ObjStrAny, RoleSelect } from './data';
+import { nextTick, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentPublicInstance, ComponentOptionsBase, ExtractPropTypes, ComputedRef, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, CreateComponentPublicInstanceWithMixins, PropType, Component, Ref, DefineComponent, PublicProps } from 'vue';
+import { ModelValue } from '../select-dialog/src/data';
+import { OnCleanup } from '@vue/reactivity';
+import { TreeData, TreeComponentProps, RenderContentFunction, AllowDragFunction, AllowDropFunction, TreeNodeData, TreeKey, FakeNode, TreeNodeLoadedDefaultProps, TreeStoreNodesMap, LoadFunction, FilterNodeMethodFunction, FilterValue, NodeDropType, TreeOptionProps } from 'element-plus/es/components/tree';
+import { default as __DTS_DEFAULT_0__ } from 'element-plus/es/components/tree/src/model/node';
+import { Nullable } from 'element-plus/es/utils';
+import { Translator } from 'element-plus/es/hooks';
+/**
+ * 设置默认显示值
+ */
+declare function setNodesObj(node: {
+    [key: ModelValue]: ObjStrAny;
+} | ObjStrAny[]): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        suffix?(_: {}): any;
+    };
+    refs: {
+        refSelectDialog: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                appendToBody: boolean;
+                separator: string;
+                getName: Function;
+            }> & Omit<{
+                readonly appendToBody: boolean;
+                readonly separator: string;
+                readonly getName: Function;
+                readonly value?: ModelValue[] | undefined;
+                readonly title?: string | undefined;
+                readonly modelValue?: ModelValue[] | undefined;
+                readonly width?: string | number | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly placeholder?: string | undefined;
+                readonly setInputName?: Function | undefined;
+                readonly getNameExplain?: Function | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "appendToBody" | "separator" | "getName">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+                width: {
+                    type: (NumberConstructor | StringConstructor)[];
+                };
+                title: {
+                    type: StringConstructor[];
+                };
+                modelValue: {
+                    type: {
+                        (arrayLength: number): ModelValue[];
+                        (...items: ModelValue[]): ModelValue[];
+                        new (arrayLength: number): ModelValue[];
+                        new (...items: ModelValue[]): ModelValue[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    }[];
+                };
+                placeholder: {
+                    type: StringConstructor;
+                };
+                value: {
+                    type: {
+                        (arrayLength: number): ModelValue[];
+                        (...items: ModelValue[]): ModelValue[];
+                        new (arrayLength: number): ModelValue[];
+                        new (...items: ModelValue[]): ModelValue[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    }[];
+                };
+                separator: {
+                    type: StringConstructor[];
+                    default: string;
+                };
+                appendToBody: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                getName: {
+                    type: FunctionConstructor[];
+                    default(): (v: any) => any;
+                };
+                setInputName: {
+                    type: FunctionConstructor[];
+                };
+                getNameExplain: {
+                    type: FunctionConstructor[];
+                };
+                disabled: {
+                    type: BooleanConstructor[];
+                };
+            }>> & Readonly<{}>, {
+                inputName: ComputedRef<string>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+                appendToBody: boolean;
+                separator: string;
+                getName: Function;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            appendToBody: boolean;
+            separator: string;
+            getName: Function;
+        }> & Omit<Readonly< ExtractPropTypes<{
+            width: {
+                type: (NumberConstructor | StringConstructor)[];
+            };
+            title: {
+                type: StringConstructor[];
+            };
+            modelValue: {
+                type: {
+                    (arrayLength: number): ModelValue[];
+                    (...items: ModelValue[]): ModelValue[];
+                    new (arrayLength: number): ModelValue[];
+                    new (...items: ModelValue[]): ModelValue[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }[];
+            };
+            placeholder: {
+                type: StringConstructor;
+            };
+            value: {
+                type: {
+                    (arrayLength: number): ModelValue[];
+                    (...items: ModelValue[]): ModelValue[];
+                    new (arrayLength: number): ModelValue[];
+                    new (...items: ModelValue[]): ModelValue[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }[];
+            };
+            separator: {
+                type: StringConstructor[];
+                default: string;
+            };
+            appendToBody: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            getName: {
+                type: FunctionConstructor[];
+                default(): (v: any) => any;
+            };
+            setInputName: {
+                type: FunctionConstructor[];
+            };
+            getNameExplain: {
+                type: FunctionConstructor[];
+            };
+            disabled: {
+                type: BooleanConstructor[];
+            };
+        }>> & Readonly<{}>, "inputName" | ("appendToBody" | "separator" | "getName")> & ShallowUnwrapRef<{
+            inputName: ComputedRef<string>;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: Partial<Record<string, (_: {}) => any>> & {
+                suffix?(_: {}): any;
+            };
+        }) | null;
+        refTree: ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                refEl: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+                    data: {
+                        type: PropType<TreeData>;
+                        default: () => never[];
+                    };
+                    emptyText: {
+                        type: StringConstructor;
+                    };
+                    renderAfterExpand: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    nodeKey: StringConstructor;
+                    checkStrictly: BooleanConstructor;
+                    defaultExpandAll: BooleanConstructor;
+                    expandOnClickNode: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    checkOnClickNode: BooleanConstructor;
+                    checkOnClickLeaf: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    checkDescendants: BooleanConstructor;
+                    autoExpandParent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    defaultCheckedKeys: PropType< TreeComponentProps["defaultCheckedKeys"]>;
+                    defaultExpandedKeys: PropType< TreeComponentProps["defaultExpandedKeys"]>;
+                    currentNodeKey: PropType<string | number>;
+                    renderContent: {
+                        type: PropType<RenderContentFunction>;
+                    };
+                    showCheckbox: BooleanConstructor;
+                    draggable: BooleanConstructor;
+                    allowDrag: {
+                        type: PropType<AllowDragFunction>;
+                    };
+                    allowDrop: {
+                        type: PropType<AllowDropFunction>;
+                    };
+                    props: {
+                        type: PropType< TreeComponentProps["props"]>;
+                        default: () => {
+                            children: string;
+                            label: string;
+                            disabled: string;
+                        };
+                    };
+                    lazy: BooleanConstructor;
+                    highlightCurrent: BooleanConstructor;
+                    load: PropType< TreeComponentProps["load"]>;
+                    filterNodeMethod: PropType< TreeComponentProps["filterNodeMethod"]>;
+                    accordion: BooleanConstructor;
+                    indent: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    icon: {
+                        type: PropType<string | Component>;
+                    };
+                }>> & {
+                    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+                }, {
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    store: Ref<{
+                        currentNode: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        } | null;
+                        currentNodeKey: TreeKey | null;
+                        nodesMap: TreeStoreNodesMap;
+                        root: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        };
+                        data: TreeNodeData[];
+                        lazy: boolean;
+                        load?: LoadFunction | undefined;
+                        filterNodeMethod?: FilterNodeMethodFunction | undefined;
+                        key: TreeKey;
+                        defaultCheckedKeys?: TreeKey[] | undefined;
+                        checkStrictly: boolean;
+                        defaultExpandedKeys?: TreeKey[] | undefined;
+                        autoExpandParent: boolean;
+                        defaultExpandAll: boolean;
+                        checkDescendants: boolean;
+                        props: {
+                            children?: string | undefined;
+                            label?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string)) | undefined;
+                            disabled?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                            isLeaf?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                            class?: ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string | {
+                                [key: string]: boolean;
+                            }) | undefined;
+                        };
+                        initialize: () => void;
+                        filter: (value: FilterValue) => void;
+                        setData: (newVal: TreeData) => void;
+                        getNode: (data: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => __DTS_DEFAULT_0__;
+                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                        remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                        _initDefaultCheckedNodes: () => void;
+                        _initDefaultCheckedNode: (node: __DTS_DEFAULT_0__) => void;
+                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                        registerNode: (node: __DTS_DEFAULT_0__) => void;
+                        deregisterNode: (node: __DTS_DEFAULT_0__) => void;
+                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                        getHalfCheckedNodes: () => TreeNodeData[];
+                        getHalfCheckedKeys: () => TreeKey[];
+                        _getAllNodes: () => __DTS_DEFAULT_0__[];
+                        updateChildren: (key: TreeKey, data: TreeData) => void;
+                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                            [key: string]: boolean;
+                        }) => void;
+                        setCheckedNodes: (array: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                        getCurrentNode: () => __DTS_DEFAULT_0__ | null;
+                        setCurrentNode: (currentNode: __DTS_DEFAULT_0__) => void;
+                        setUserCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                    }>;
+                    root: Ref<{
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    }>;
+                    currentNode: Ref<{
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    } | null>;
+                    dragState: Ref<{
+                        allowDrop: boolean;
+                        dropType: NodeDropType | null;
+                        draggingNode: {
+                            node: {
+                                id: number;
+                                text: string | null;
+                                checked: boolean;
+                                indeterminate: boolean;
+                                data: TreeNodeData;
+                                expanded: boolean;
+                                parent: any | null;
+                                visible: boolean;
+                                isCurrent: boolean;
+                                store: any;
+                                isLeafByUser: boolean | undefined;
+                                isLeaf: boolean | undefined;
+                                canFocus: boolean;
+                                level: number;
+                                loaded: boolean;
+                                childNodes: any[];
+                                loading: boolean;
+                                initialize: () => void;
+                                setData: (data: TreeNodeData) => void;
+                                readonly label: string;
+                                readonly key: TreeKey | null | undefined;
+                                readonly disabled: boolean;
+                                readonly nextSibling: any | null;
+                                readonly previousSibling: any | null;
+                                contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                                remove: () => void;
+                                insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                                insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                removeChild: (child: __DTS_DEFAULT_0__) => void;
+                                removeChildByData: (data: TreeNodeData | null) => void;
+                                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                                doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                collapse: () => void;
+                                shouldLoadData: () => boolean;
+                                updateLeafState: () => void;
+                                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                                updateChildren: () => void;
+                                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                                reInitChecked: () => void;
+                            };
+                            $el?: HTMLElement | undefined;
+                        } | null;
+                        showDropIndicator: boolean;
+                        dropNode: {
+                            node: {
+                                id: number;
+                                text: string | null;
+                                checked: boolean;
+                                indeterminate: boolean;
+                                data: TreeNodeData;
+                                expanded: boolean;
+                                parent: any | null;
+                                visible: boolean;
+                                isCurrent: boolean;
+                                store: any;
+                                isLeafByUser: boolean | undefined;
+                                isLeaf: boolean | undefined;
+                                canFocus: boolean;
+                                level: number;
+                                loaded: boolean;
+                                childNodes: any[];
+                                loading: boolean;
+                                initialize: () => void;
+                                setData: (data: TreeNodeData) => void;
+                                readonly label: string;
+                                readonly key: TreeKey | null | undefined;
+                                readonly disabled: boolean;
+                                readonly nextSibling: any | null;
+                                readonly previousSibling: any | null;
+                                contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                                remove: () => void;
+                                insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                                insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                removeChild: (child: __DTS_DEFAULT_0__) => void;
+                                removeChildByData: (data: TreeNodeData | null) => void;
+                                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                                doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                collapse: () => void;
+                                shouldLoadData: () => boolean;
+                                updateLeafState: () => void;
+                                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                                updateChildren: () => void;
+                                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                                reInitChecked: () => void;
+                            };
+                            $el?: HTMLElement | undefined;
+                        } | null;
+                    }>;
+                    el$: Ref<Nullable<HTMLElement>>;
+                    dropIndicator$: Ref<Nullable<HTMLElement>>;
+                    isEmpty: ComputedRef<boolean>;
+                    filter: (value: FilterValue) => void;
+                    getNodeKey: (node: __DTS_DEFAULT_0__) => any;
+                    getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getCurrentNode: () => TreeNodeData | null;
+                    getCurrentKey: () => TreeKey | null;
+                    setCheckedNodes: (nodes: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    setCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentKey: (key?: TreeKey, shouldAutoExpandParent?: boolean) => void;
+                    t: Translator;
+                    getNode: (data: TreeKey | TreeNodeData) => __DTS_DEFAULT_0__;
+                    remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                    insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    handleNodeExpand: (nodeData: TreeNodeData, node: __DTS_DEFAULT_0__, instance: ComponentInternalInstance) => void;
+                    updateKeyChildren: (key: TreeKey, data: TreeData) => void;
+                }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, string[], VNodeProps & AllowedComponentProps & ComponentCustomProps, {
+                    data: TreeData;
+                    props: TreeOptionProps;
+                    checkStrictly: boolean;
+                    lazy: boolean;
+                    accordion: boolean;
+                    draggable: boolean;
+                    defaultExpandAll: boolean;
+                    indent: number;
+                    autoExpandParent: boolean;
+                    checkDescendants: boolean;
+                    renderAfterExpand: boolean;
+                    showCheckbox: boolean;
+                    expandOnClickNode: boolean;
+                    checkOnClickNode: boolean;
+                    checkOnClickLeaf: boolean;
+                    highlightCurrent: boolean;
+                }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly< ExtractPropTypes<{
+                    data: {
+                        type: PropType<TreeData>;
+                        default: () => never[];
+                    };
+                    emptyText: {
+                        type: StringConstructor;
+                    };
+                    renderAfterExpand: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    nodeKey: StringConstructor;
+                    checkStrictly: BooleanConstructor;
+                    defaultExpandAll: BooleanConstructor;
+                    expandOnClickNode: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    checkOnClickNode: BooleanConstructor;
+                    checkOnClickLeaf: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    checkDescendants: BooleanConstructor;
+                    autoExpandParent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    defaultCheckedKeys: PropType< TreeComponentProps["defaultCheckedKeys"]>;
+                    defaultExpandedKeys: PropType< TreeComponentProps["defaultExpandedKeys"]>;
+                    currentNodeKey: PropType<string | number>;
+                    renderContent: {
+                        type: PropType<RenderContentFunction>;
+                    };
+                    showCheckbox: BooleanConstructor;
+                    draggable: BooleanConstructor;
+                    allowDrag: {
+                        type: PropType<AllowDragFunction>;
+                    };
+                    allowDrop: {
+                        type: PropType<AllowDropFunction>;
+                    };
+                    props: {
+                        type: PropType< TreeComponentProps["props"]>;
+                        default: () => {
+                            children: string;
+                            label: string;
+                            disabled: string;
+                        };
+                    };
+                    lazy: BooleanConstructor;
+                    highlightCurrent: BooleanConstructor;
+                    load: PropType< TreeComponentProps["load"]>;
+                    filterNodeMethod: PropType< TreeComponentProps["filterNodeMethod"]>;
+                    accordion: BooleanConstructor;
+                    indent: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    icon: {
+                        type: PropType<string | Component>;
+                    };
+                }>> & {
+                    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+                }, {
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    store: Ref<{
+                        currentNode: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        } | null;
+                        currentNodeKey: TreeKey | null;
+                        nodesMap: TreeStoreNodesMap;
+                        root: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        };
+                        data: TreeNodeData[];
+                        lazy: boolean;
+                        load?: LoadFunction | undefined;
+                        filterNodeMethod?: FilterNodeMethodFunction | undefined;
+                        key: TreeKey;
+                        defaultCheckedKeys?: TreeKey[] | undefined;
+                        checkStrictly: boolean;
+                        defaultExpandedKeys?: TreeKey[] | undefined;
+                        autoExpandParent: boolean;
+                        defaultExpandAll: boolean;
+                        checkDescendants: boolean;
+                        props: {
+                            children?: string | undefined;
+                            label?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string)) | undefined;
+                            disabled?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                            isLeaf?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                            class?: ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string | {
+                                [key: string]: boolean;
+                            }) | undefined;
+                        };
+                        initialize: () => void;
+                        filter: (value: FilterValue) => void;
+                        setData: (newVal: TreeData) => void;
+                        getNode: (data: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => __DTS_DEFAULT_0__;
+                        insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                        insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                        remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                        append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                        _initDefaultCheckedNodes: () => void;
+                        _initDefaultCheckedNode: (node: __DTS_DEFAULT_0__) => void;
+                        setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                        registerNode: (node: __DTS_DEFAULT_0__) => void;
+                        deregisterNode: (node: __DTS_DEFAULT_0__) => void;
+                        getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                        getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                        getHalfCheckedNodes: () => TreeNodeData[];
+                        getHalfCheckedKeys: () => TreeKey[];
+                        _getAllNodes: () => __DTS_DEFAULT_0__[];
+                        updateChildren: (key: TreeKey, data: TreeData) => void;
+                        _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                            [key: string]: boolean;
+                        }) => void;
+                        setCheckedNodes: (array: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                        setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                        setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                        setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                        getCurrentNode: () => __DTS_DEFAULT_0__ | null;
+                        setCurrentNode: (currentNode: __DTS_DEFAULT_0__) => void;
+                        setUserCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                        setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                    }>;
+                    root: Ref<{
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    }>;
+                    currentNode: Ref<{
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    } | null>;
+                    dragState: Ref<{
+                        allowDrop: boolean;
+                        dropType: NodeDropType | null;
+                        draggingNode: {
+                            node: {
+                                id: number;
+                                text: string | null;
+                                checked: boolean;
+                                indeterminate: boolean;
+                                data: TreeNodeData;
+                                expanded: boolean;
+                                parent: any | null;
+                                visible: boolean;
+                                isCurrent: boolean;
+                                store: any;
+                                isLeafByUser: boolean | undefined;
+                                isLeaf: boolean | undefined;
+                                canFocus: boolean;
+                                level: number;
+                                loaded: boolean;
+                                childNodes: any[];
+                                loading: boolean;
+                                initialize: () => void;
+                                setData: (data: TreeNodeData) => void;
+                                readonly label: string;
+                                readonly key: TreeKey | null | undefined;
+                                readonly disabled: boolean;
+                                readonly nextSibling: any | null;
+                                readonly previousSibling: any | null;
+                                contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                                remove: () => void;
+                                insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                                insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                removeChild: (child: __DTS_DEFAULT_0__) => void;
+                                removeChildByData: (data: TreeNodeData | null) => void;
+                                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                                doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                collapse: () => void;
+                                shouldLoadData: () => boolean;
+                                updateLeafState: () => void;
+                                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                                updateChildren: () => void;
+                                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                                reInitChecked: () => void;
+                            };
+                            $el?: HTMLElement | undefined;
+                        } | null;
+                        showDropIndicator: boolean;
+                        dropNode: {
+                            node: {
+                                id: number;
+                                text: string | null;
+                                checked: boolean;
+                                indeterminate: boolean;
+                                data: TreeNodeData;
+                                expanded: boolean;
+                                parent: any | null;
+                                visible: boolean;
+                                isCurrent: boolean;
+                                store: any;
+                                isLeafByUser: boolean | undefined;
+                                isLeaf: boolean | undefined;
+                                canFocus: boolean;
+                                level: number;
+                                loaded: boolean;
+                                childNodes: any[];
+                                loading: boolean;
+                                initialize: () => void;
+                                setData: (data: TreeNodeData) => void;
+                                readonly label: string;
+                                readonly key: TreeKey | null | undefined;
+                                readonly disabled: boolean;
+                                readonly nextSibling: any | null;
+                                readonly previousSibling: any | null;
+                                contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                                remove: () => void;
+                                insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                                insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                                removeChild: (child: __DTS_DEFAULT_0__) => void;
+                                removeChildByData: (data: TreeNodeData | null) => void;
+                                expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                                doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                collapse: () => void;
+                                shouldLoadData: () => boolean;
+                                updateLeafState: () => void;
+                                setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                                getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                                updateChildren: () => void;
+                                loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                                eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                                reInitChecked: () => void;
+                            };
+                            $el?: HTMLElement | undefined;
+                        } | null;
+                    }>;
+                    el$: Ref<Nullable<HTMLElement>>;
+                    dropIndicator$: Ref<Nullable<HTMLElement>>;
+                    isEmpty: ComputedRef<boolean>;
+                    filter: (value: FilterValue) => void;
+                    getNodeKey: (node: __DTS_DEFAULT_0__) => any;
+                    getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getCurrentNode: () => TreeNodeData | null;
+                    getCurrentKey: () => TreeKey | null;
+                    setCheckedNodes: (nodes: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    setCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentKey: (key?: TreeKey, shouldAutoExpandParent?: boolean) => void;
+                    t: Translator;
+                    getNode: (data: TreeKey | TreeNodeData) => __DTS_DEFAULT_0__;
+                    remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                    insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    handleNodeExpand: (nodeData: TreeNodeData, node: __DTS_DEFAULT_0__, instance: ComponentInternalInstance) => void;
+                    updateKeyChildren: (key: TreeKey, data: TreeData) => void;
+                }, {}, {}, {}, {
+                    data: TreeData;
+                    props: TreeOptionProps;
+                    checkStrictly: boolean;
+                    lazy: boolean;
+                    accordion: boolean;
+                    draggable: boolean;
+                    defaultExpandAll: boolean;
+                    indent: number;
+                    autoExpandParent: boolean;
+                    checkDescendants: boolean;
+                    renderAfterExpand: boolean;
+                    showCheckbox: boolean;
+                    expandOnClickNode: boolean;
+                    checkOnClickNode: boolean;
+                    checkOnClickLeaf: boolean;
+                    highlightCurrent: boolean;
+                }> | null;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+                refEl: Ref<any, any>;
+            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, "refEl"> & ShallowUnwrapRef<{
+            refEl: Ref<any, any>;
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: Partial<Record<string, (_: any) => any>>;
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ExtractPropTypes<{
+    expandAll: {
+        type: BooleanConstructor[];
+    };
+    modelValue: {
+        type: {
+            (arrayLength: number): ModelValue[];
+            (...items: ModelValue[]): ModelValue[];
+            new (arrayLength: number): ModelValue[];
+            new (...items: ModelValue[]): ModelValue[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }[];
+    };
+    appendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor[];
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): ObjStrAny[];
+            (...items: ObjStrAny[]): ObjStrAny[];
+            new (arrayLength: number): ObjStrAny[];
+            new (...items: ObjStrAny[]): ObjStrAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    props: {
+        type: PropType<RoleSelect>;
+        default(): {};
+    };
+}>, {
+    setNodesObj: typeof setNodesObj;
+    getInputName(): any;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    expandAll: {
+        type: BooleanConstructor[];
+    };
+    modelValue: {
+        type: {
+            (arrayLength: number): ModelValue[];
+            (...items: ModelValue[]): ModelValue[];
+            new (arrayLength: number): ModelValue[];
+            new (...items: ModelValue[]): ModelValue[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }[];
+    };
+    appendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor[];
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    placeholder: {
+        type: StringConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor[];
+    };
+    options: {
+        type: {
+            (arrayLength: number): ObjStrAny[];
+            (...items: ObjStrAny[]): ObjStrAny[];
+            new (arrayLength: number): ObjStrAny[];
+            new (...items: ObjStrAny[]): ObjStrAny[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+    props: {
+        type: PropType<RoleSelect>;
+        default(): {};
+    };
+}>> & Readonly<{}>, {
+    props: RoleSelect;
+    title: string;
+    appendToBody: boolean;
+    options: ObjStrAny[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    refSelectDialog: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            appendToBody: boolean;
+            separator: string;
+            getName: Function;
+        }> & Omit<{
+            readonly appendToBody: boolean;
+            readonly separator: string;
+            readonly getName: Function;
+            readonly value?: ModelValue[] | undefined;
+            readonly title?: string | undefined;
+            readonly modelValue?: ModelValue[] | undefined;
+            readonly width?: string | number | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly placeholder?: string | undefined;
+            readonly setInputName?: Function | undefined;
+            readonly getNameExplain?: Function | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "appendToBody" | "separator" | "getName">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: ComponentOptionsBase<Readonly< ExtractPropTypes<{
+            width: {
+                type: (NumberConstructor | StringConstructor)[];
+            };
+            title: {
+                type: StringConstructor[];
+            };
+            modelValue: {
+                type: {
+                    (arrayLength: number): ModelValue[];
+                    (...items: ModelValue[]): ModelValue[];
+                    new (arrayLength: number): ModelValue[];
+                    new (...items: ModelValue[]): ModelValue[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }[];
+            };
+            placeholder: {
+                type: StringConstructor;
+            };
+            value: {
+                type: {
+                    (arrayLength: number): ModelValue[];
+                    (...items: ModelValue[]): ModelValue[];
+                    new (arrayLength: number): ModelValue[];
+                    new (...items: ModelValue[]): ModelValue[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }[];
+            };
+            separator: {
+                type: StringConstructor[];
+                default: string;
+            };
+            appendToBody: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            getName: {
+                type: FunctionConstructor[];
+                default(): (v: any) => any;
+            };
+            setInputName: {
+                type: FunctionConstructor[];
+            };
+            getNameExplain: {
+                type: FunctionConstructor[];
+            };
+            disabled: {
+                type: BooleanConstructor[];
+            };
+        }>> & Readonly<{}>, {
+            inputName: ComputedRef<string>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            appendToBody: boolean;
+            separator: string;
+            getName: Function;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        appendToBody: boolean;
+        separator: string;
+        getName: Function;
+    }> & Omit<Readonly< ExtractPropTypes<{
+        width: {
+            type: (NumberConstructor | StringConstructor)[];
+        };
+        title: {
+            type: StringConstructor[];
+        };
+        modelValue: {
+            type: {
+                (arrayLength: number): ModelValue[];
+                (...items: ModelValue[]): ModelValue[];
+                new (arrayLength: number): ModelValue[];
+                new (...items: ModelValue[]): ModelValue[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }[];
+        };
+        placeholder: {
+            type: StringConstructor;
+        };
+        value: {
+            type: {
+                (arrayLength: number): ModelValue[];
+                (...items: ModelValue[]): ModelValue[];
+                new (arrayLength: number): ModelValue[];
+                new (...items: ModelValue[]): ModelValue[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }[];
+        };
+        separator: {
+            type: StringConstructor[];
+            default: string;
+        };
+        appendToBody: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        getName: {
+            type: FunctionConstructor[];
+            default(): (v: any) => any;
+        };
+        setInputName: {
+            type: FunctionConstructor[];
+        };
+        getNameExplain: {
+            type: FunctionConstructor[];
+        };
+        disabled: {
+            type: BooleanConstructor[];
+        };
+    }>> & Readonly<{}>, "inputName" | ("appendToBody" | "separator" | "getName")> & ShallowUnwrapRef<{
+        inputName: ComputedRef<string>;
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: Partial<Record<string, (_: {}) => any>> & {
+            suffix?(_: {}): any;
+        };
+    }) | null;
+    refTree: ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            refEl: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+                data: {
+                    type: PropType<TreeData>;
+                    default: () => never[];
+                };
+                emptyText: {
+                    type: StringConstructor;
+                };
+                renderAfterExpand: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                nodeKey: StringConstructor;
+                checkStrictly: BooleanConstructor;
+                defaultExpandAll: BooleanConstructor;
+                expandOnClickNode: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                checkOnClickNode: BooleanConstructor;
+                checkOnClickLeaf: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                checkDescendants: BooleanConstructor;
+                autoExpandParent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                defaultCheckedKeys: PropType< TreeComponentProps["defaultCheckedKeys"]>;
+                defaultExpandedKeys: PropType< TreeComponentProps["defaultExpandedKeys"]>;
+                currentNodeKey: PropType<string | number>;
+                renderContent: {
+                    type: PropType<RenderContentFunction>;
+                };
+                showCheckbox: BooleanConstructor;
+                draggable: BooleanConstructor;
+                allowDrag: {
+                    type: PropType<AllowDragFunction>;
+                };
+                allowDrop: {
+                    type: PropType<AllowDropFunction>;
+                };
+                props: {
+                    type: PropType< TreeComponentProps["props"]>;
+                    default: () => {
+                        children: string;
+                        label: string;
+                        disabled: string;
+                    };
+                };
+                lazy: BooleanConstructor;
+                highlightCurrent: BooleanConstructor;
+                load: PropType< TreeComponentProps["load"]>;
+                filterNodeMethod: PropType< TreeComponentProps["filterNodeMethod"]>;
+                accordion: BooleanConstructor;
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                icon: {
+                    type: PropType<string | Component>;
+                };
+            }>> & {
+                [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+            }, {
+                ns: {
+                    namespace: ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                store: Ref<{
+                    currentNode: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    } | null;
+                    currentNodeKey: TreeKey | null;
+                    nodesMap: TreeStoreNodesMap;
+                    root: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    data: TreeNodeData[];
+                    lazy: boolean;
+                    load?: LoadFunction | undefined;
+                    filterNodeMethod?: FilterNodeMethodFunction | undefined;
+                    key: TreeKey;
+                    defaultCheckedKeys?: TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string)) | undefined;
+                        disabled?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                        isLeaf?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                        class?: ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: FilterValue) => void;
+                    setData: (newVal: TreeData) => void;
+                    getNode: (data: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => __DTS_DEFAULT_0__;
+                    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: __DTS_DEFAULT_0__) => void;
+                    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                    registerNode: (node: __DTS_DEFAULT_0__) => void;
+                    deregisterNode: (node: __DTS_DEFAULT_0__) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    _getAllNodes: () => __DTS_DEFAULT_0__[];
+                    updateChildren: (key: TreeKey, data: TreeData) => void;
+                    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => __DTS_DEFAULT_0__ | null;
+                    setCurrentNode: (currentNode: __DTS_DEFAULT_0__) => void;
+                    setUserCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                }>;
+                root: Ref<{
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    removeChild: (child: __DTS_DEFAULT_0__) => void;
+                    removeChildByData: (data: TreeNodeData | null) => void;
+                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                    reInitChecked: () => void;
+                }>;
+                currentNode: Ref<{
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    removeChild: (child: __DTS_DEFAULT_0__) => void;
+                    removeChildByData: (data: TreeNodeData | null) => void;
+                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                    reInitChecked: () => void;
+                } | null>;
+                dragState: Ref<{
+                    allowDrop: boolean;
+                    dropType: NodeDropType | null;
+                    draggingNode: {
+                        node: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        };
+                        $el?: HTMLElement | undefined;
+                    } | null;
+                    showDropIndicator: boolean;
+                    dropNode: {
+                        node: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        };
+                        $el?: HTMLElement | undefined;
+                    } | null;
+                }>;
+                el$: Ref<Nullable<HTMLElement>>;
+                dropIndicator$: Ref<Nullable<HTMLElement>>;
+                isEmpty: ComputedRef<boolean>;
+                filter: (value: FilterValue) => void;
+                getNodeKey: (node: __DTS_DEFAULT_0__) => any;
+                getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
+                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                getCurrentNode: () => TreeNodeData | null;
+                getCurrentKey: () => TreeKey | null;
+                setCheckedNodes: (nodes: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                getHalfCheckedNodes: () => TreeNodeData[];
+                getHalfCheckedKeys: () => TreeKey[];
+                setCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                setCurrentKey: (key?: TreeKey, shouldAutoExpandParent?: boolean) => void;
+                t: Translator;
+                getNode: (data: TreeKey | TreeNodeData) => __DTS_DEFAULT_0__;
+                remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                handleNodeExpand: (nodeData: TreeNodeData, node: __DTS_DEFAULT_0__, instance: ComponentInternalInstance) => void;
+                updateKeyChildren: (key: TreeKey, data: TreeData) => void;
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, string[], VNodeProps & AllowedComponentProps & ComponentCustomProps, {
+                data: TreeData;
+                props: TreeOptionProps;
+                checkStrictly: boolean;
+                lazy: boolean;
+                accordion: boolean;
+                draggable: boolean;
+                defaultExpandAll: boolean;
+                indent: number;
+                autoExpandParent: boolean;
+                checkDescendants: boolean;
+                renderAfterExpand: boolean;
+                showCheckbox: boolean;
+                expandOnClickNode: boolean;
+                checkOnClickNode: boolean;
+                checkOnClickLeaf: boolean;
+                highlightCurrent: boolean;
+            }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly< ExtractPropTypes<{
+                data: {
+                    type: PropType<TreeData>;
+                    default: () => never[];
+                };
+                emptyText: {
+                    type: StringConstructor;
+                };
+                renderAfterExpand: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                nodeKey: StringConstructor;
+                checkStrictly: BooleanConstructor;
+                defaultExpandAll: BooleanConstructor;
+                expandOnClickNode: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                checkOnClickNode: BooleanConstructor;
+                checkOnClickLeaf: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                checkDescendants: BooleanConstructor;
+                autoExpandParent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                defaultCheckedKeys: PropType< TreeComponentProps["defaultCheckedKeys"]>;
+                defaultExpandedKeys: PropType< TreeComponentProps["defaultExpandedKeys"]>;
+                currentNodeKey: PropType<string | number>;
+                renderContent: {
+                    type: PropType<RenderContentFunction>;
+                };
+                showCheckbox: BooleanConstructor;
+                draggable: BooleanConstructor;
+                allowDrag: {
+                    type: PropType<AllowDragFunction>;
+                };
+                allowDrop: {
+                    type: PropType<AllowDropFunction>;
+                };
+                props: {
+                    type: PropType< TreeComponentProps["props"]>;
+                    default: () => {
+                        children: string;
+                        label: string;
+                        disabled: string;
+                    };
+                };
+                lazy: BooleanConstructor;
+                highlightCurrent: BooleanConstructor;
+                load: PropType< TreeComponentProps["load"]>;
+                filterNodeMethod: PropType< TreeComponentProps["filterNodeMethod"]>;
+                accordion: BooleanConstructor;
+                indent: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                icon: {
+                    type: PropType<string | Component>;
+                };
+            }>> & {
+                [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+            }, {
+                ns: {
+                    namespace: ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                store: Ref<{
+                    currentNode: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    } | null;
+                    currentNodeKey: TreeKey | null;
+                    nodesMap: TreeStoreNodesMap;
+                    root: {
+                        id: number;
+                        text: string | null;
+                        checked: boolean;
+                        indeterminate: boolean;
+                        data: TreeNodeData;
+                        expanded: boolean;
+                        parent: any | null;
+                        visible: boolean;
+                        isCurrent: boolean;
+                        store: any;
+                        isLeafByUser: boolean | undefined;
+                        isLeaf: boolean | undefined;
+                        canFocus: boolean;
+                        level: number;
+                        loaded: boolean;
+                        childNodes: any[];
+                        loading: boolean;
+                        initialize: () => void;
+                        setData: (data: TreeNodeData) => void;
+                        readonly label: string;
+                        readonly key: TreeKey | null | undefined;
+                        readonly disabled: boolean;
+                        readonly nextSibling: any | null;
+                        readonly previousSibling: any | null;
+                        contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                        remove: () => void;
+                        insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                        insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                        removeChild: (child: __DTS_DEFAULT_0__) => void;
+                        removeChildByData: (data: TreeNodeData | null) => void;
+                        expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                        doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        collapse: () => void;
+                        shouldLoadData: () => boolean;
+                        updateLeafState: () => void;
+                        setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                        getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                        updateChildren: () => void;
+                        loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                        eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                        reInitChecked: () => void;
+                    };
+                    data: TreeNodeData[];
+                    lazy: boolean;
+                    load?: LoadFunction | undefined;
+                    filterNodeMethod?: FilterNodeMethodFunction | undefined;
+                    key: TreeKey;
+                    defaultCheckedKeys?: TreeKey[] | undefined;
+                    checkStrictly: boolean;
+                    defaultExpandedKeys?: TreeKey[] | undefined;
+                    autoExpandParent: boolean;
+                    defaultExpandAll: boolean;
+                    checkDescendants: boolean;
+                    props: {
+                        children?: string | undefined;
+                        label?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string)) | undefined;
+                        disabled?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                        isLeaf?: (string | ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => boolean)) | undefined;
+                        class?: ((data: TreeNodeData, node: __DTS_DEFAULT_0__) => string | {
+                            [key: string]: boolean;
+                        }) | undefined;
+                    };
+                    initialize: () => void;
+                    filter: (value: FilterValue) => void;
+                    setData: (newVal: TreeData) => void;
+                    getNode: (data: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => __DTS_DEFAULT_0__;
+                    insertBefore: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    insertAfter: (data: TreeNodeData, refData: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                    append: (data: TreeNodeData, parentData: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                    _initDefaultCheckedNodes: () => void;
+                    _initDefaultCheckedNode: (node: __DTS_DEFAULT_0__) => void;
+                    setDefaultCheckedKey: (newVal: TreeKey[]) => void;
+                    registerNode: (node: __DTS_DEFAULT_0__) => void;
+                    deregisterNode: (node: __DTS_DEFAULT_0__) => void;
+                    getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                    getHalfCheckedNodes: () => TreeNodeData[];
+                    getHalfCheckedKeys: () => TreeKey[];
+                    _getAllNodes: () => __DTS_DEFAULT_0__[];
+                    updateChildren: (key: TreeKey, data: TreeData) => void;
+                    _setCheckedKeys: (key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+                        [key: string]: boolean;
+                    }) => void;
+                    setCheckedNodes: (array: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                    setDefaultExpandedKeys: (keys: TreeKey[]) => void;
+                    setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                    getCurrentNode: () => __DTS_DEFAULT_0__ | null;
+                    setCurrentNode: (currentNode: __DTS_DEFAULT_0__) => void;
+                    setUserCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                    setCurrentNodeKey: (key: TreeKey | null, shouldAutoExpandParent?: boolean) => void;
+                }>;
+                root: Ref<{
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    removeChild: (child: __DTS_DEFAULT_0__) => void;
+                    removeChildByData: (data: TreeNodeData | null) => void;
+                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                    reInitChecked: () => void;
+                }>;
+                currentNode: Ref<{
+                    id: number;
+                    text: string | null;
+                    checked: boolean;
+                    indeterminate: boolean;
+                    data: TreeNodeData;
+                    expanded: boolean;
+                    parent: any | null;
+                    visible: boolean;
+                    isCurrent: boolean;
+                    store: any;
+                    isLeafByUser: boolean | undefined;
+                    isLeaf: boolean | undefined;
+                    canFocus: boolean;
+                    level: number;
+                    loaded: boolean;
+                    childNodes: any[];
+                    loading: boolean;
+                    initialize: () => void;
+                    setData: (data: TreeNodeData) => void;
+                    readonly label: string;
+                    readonly key: TreeKey | null | undefined;
+                    readonly disabled: boolean;
+                    readonly nextSibling: any | null;
+                    readonly previousSibling: any | null;
+                    contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                    remove: () => void;
+                    insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                    insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                    removeChild: (child: __DTS_DEFAULT_0__) => void;
+                    removeChildByData: (data: TreeNodeData | null) => void;
+                    expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                    doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    collapse: () => void;
+                    shouldLoadData: () => boolean;
+                    updateLeafState: () => void;
+                    setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                    getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                    updateChildren: () => void;
+                    loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                    eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                    reInitChecked: () => void;
+                } | null>;
+                dragState: Ref<{
+                    allowDrop: boolean;
+                    dropType: NodeDropType | null;
+                    draggingNode: {
+                        node: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        };
+                        $el?: HTMLElement | undefined;
+                    } | null;
+                    showDropIndicator: boolean;
+                    dropNode: {
+                        node: {
+                            id: number;
+                            text: string | null;
+                            checked: boolean;
+                            indeterminate: boolean;
+                            data: TreeNodeData;
+                            expanded: boolean;
+                            parent: any | null;
+                            visible: boolean;
+                            isCurrent: boolean;
+                            store: any;
+                            isLeafByUser: boolean | undefined;
+                            isLeaf: boolean | undefined;
+                            canFocus: boolean;
+                            level: number;
+                            loaded: boolean;
+                            childNodes: any[];
+                            loading: boolean;
+                            initialize: () => void;
+                            setData: (data: TreeNodeData) => void;
+                            readonly label: string;
+                            readonly key: TreeKey | null | undefined;
+                            readonly disabled: boolean;
+                            readonly nextSibling: any | null;
+                            readonly previousSibling: any | null;
+                            contains: (target: __DTS_DEFAULT_0__, deep?: boolean) => boolean;
+                            remove: () => void;
+                            insertChild: (child?: FakeNode | __DTS_DEFAULT_0__, index?: number, batch?: boolean) => void;
+                            insertBefore: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            insertAfter: (child: FakeNode | __DTS_DEFAULT_0__, ref: __DTS_DEFAULT_0__) => void;
+                            removeChild: (child: __DTS_DEFAULT_0__) => void;
+                            removeChildByData: (data: TreeNodeData | null) => void;
+                            expand: (callback?: (() => void) | null, expandParent?: boolean) => void;
+                            doCreateChildren: (array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            collapse: () => void;
+                            shouldLoadData: () => boolean;
+                            updateLeafState: () => void;
+                            setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void;
+                            getChildren: (forceInit?: boolean) => TreeNodeData | TreeNodeData[] | null;
+                            updateChildren: () => void;
+                            loadData: (callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps) => void;
+                            eachNode: (callback: (node: __DTS_DEFAULT_0__) => void) => void;
+                            reInitChecked: () => void;
+                        };
+                        $el?: HTMLElement | undefined;
+                    } | null;
+                }>;
+                el$: Ref<Nullable<HTMLElement>>;
+                dropIndicator$: Ref<Nullable<HTMLElement>>;
+                isEmpty: ComputedRef<boolean>;
+                filter: (value: FilterValue) => void;
+                getNodeKey: (node: __DTS_DEFAULT_0__) => any;
+                getNodePath: (data: TreeKey | TreeNodeData) => TreeNodeData[];
+                getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => TreeNodeData[];
+                getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+                getCurrentNode: () => TreeNodeData | null;
+                getCurrentKey: () => TreeKey | null;
+                setCheckedNodes: (nodes: __DTS_DEFAULT_0__[], leafOnly?: boolean) => void;
+                setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean) => void;
+                setChecked: (data: TreeKey | TreeNodeData, checked: boolean, deep: boolean) => void;
+                getHalfCheckedNodes: () => TreeNodeData[];
+                getHalfCheckedKeys: () => TreeKey[];
+                setCurrentNode: (node: __DTS_DEFAULT_0__, shouldAutoExpandParent?: boolean) => void;
+                setCurrentKey: (key?: TreeKey, shouldAutoExpandParent?: boolean) => void;
+                t: Translator;
+                getNode: (data: TreeKey | TreeNodeData) => __DTS_DEFAULT_0__;
+                remove: (data: TreeNodeData | __DTS_DEFAULT_0__) => void;
+                append: (data: TreeNodeData, parentNode: TreeNodeData | TreeKey | __DTS_DEFAULT_0__) => void;
+                insertBefore: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                insertAfter: (data: TreeNodeData, refNode: TreeKey | TreeNodeData | __DTS_DEFAULT_0__) => void;
+                handleNodeExpand: (nodeData: TreeNodeData, node: __DTS_DEFAULT_0__, instance: ComponentInternalInstance) => void;
+                updateKeyChildren: (key: TreeKey, data: TreeData) => void;
+            }, {}, {}, {}, {
+                data: TreeData;
+                props: TreeOptionProps;
+                checkStrictly: boolean;
+                lazy: boolean;
+                accordion: boolean;
+                draggable: boolean;
+                defaultExpandAll: boolean;
+                indent: number;
+                autoExpandParent: boolean;
+                checkDescendants: boolean;
+                renderAfterExpand: boolean;
+                showCheckbox: boolean;
+                expandOnClickNode: boolean;
+                checkOnClickNode: boolean;
+                checkOnClickLeaf: boolean;
+                highlightCurrent: boolean;
+            }> | null;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+            refEl: Ref<any, any>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{}> & Readonly<{}>, "refEl"> & ShallowUnwrapRef<{
+        refEl: Ref<any, any>;
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: Partial<Record<string, (_: any) => any>>;
+    }) | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};