@maxax/ui 1.1.39 → 1.1.40

package/dist/components/basic-tree/BasicTree.vue.d.ts

@@ -1,6 +1,8 @@
 import { TreeOption } from 'naive-ui';
 import { BasicTreeProps } from './interface';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<BasicTreeProps, {
+declare function __VLS_template(): any;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BasicTreeProps, {
     treeRef: Readonly<import('vue').ShallowRef<({
         $: import('vue').ComponentInternalInstance;
         $data: {};
@@ -13,7 +15,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
             readonly selectable?: boolean | undefined;
             readonly checkable?: boolean | undefined;
             readonly separator?: string | undefined;
-            readonly ignoreMode?: "none" | "children" | "parents" | undefined;
+            readonly ignoreMode?: import('..').IgnoreType | undefined;
             readonly titleField?: string | undefined;
             readonly keyField?: string | undefined;
             readonly filterMethod?: import('..').FilterFunctionType | undefined;
@@ -31,14 +33,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
             readonly droppable?: boolean | undefined;
             readonly beforeDropMethod?: ((dragKey: import('..').TreeNodeKeyType, dropKey: import('..').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean) | undefined;
             readonly autoLoad?: boolean | undefined;
-            readonly render?: ((node: import('..').TreeNode) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-                [key: string]: any;
-            }>) | undefined;
+            readonly render?: ((node: import('..').TreeNode) => import('vue').VNode) | undefined;
             readonly expandOnFilter?: boolean | undefined;
             readonly unselectOnClick?: boolean | undefined;
             readonly loading?: boolean | undefined;
-            readonly nodeClassName?: string | object | (string | object)[] | ((node: import('..').TreeNode) => string | object | (string | object)[]) | undefined;
-            readonly showLine?: boolean | import('..').ShowLine | undefined;
+            readonly nodeClassName?: (string | object | Array<string | object> | ((node: import('..').TreeNode) => string | object | Array<string | object>)) | undefined;
+            readonly showLine?: (boolean | import('..').ShowLine) | undefined;
             readonly animation?: boolean | undefined;
             readonly nodeIndent?: number | undefined;
             readonly renderNodeAmount?: number | undefined;
@@ -73,7 +73,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                     readonly selectable?: boolean | undefined;
                     readonly checkable?: boolean | undefined;
                     readonly separator?: string | undefined;
-                    readonly ignoreMode?: "none" | "children" | "parents" | undefined;
+                    readonly ignoreMode?: import('..').IgnoreType | undefined;
                     readonly titleField?: string | undefined;
                     readonly keyField?: string | undefined;
                     readonly filterMethod?: import('..').FilterFunctionType | undefined;
@@ -91,14 +91,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                     readonly droppable?: boolean | undefined;
                     readonly beforeDropMethod?: ((dragKey: import('..').TreeNodeKeyType, dropKey: import('..').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean) | undefined;
                     readonly autoLoad?: boolean | undefined;
-                    readonly render?: ((node: import('..').TreeNode) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-                        [key: string]: any;
-                    }>) | undefined;
+                    readonly render?: ((node: import('..').TreeNode) => import('vue').VNode) | undefined;
                     readonly expandOnFilter?: boolean | undefined;
                     readonly unselectOnClick?: boolean | undefined;
                     readonly loading?: boolean | undefined;
-                    readonly nodeClassName?: string | object | (string | object)[] | ((node: import('..').TreeNode) => string | object | (string | object)[]) | undefined;
-                    readonly showLine?: boolean | import('..').ShowLine | undefined;
+                    readonly nodeClassName?: (string | object | Array<string | object> | ((node: import('..').TreeNode) => string | object | Array<string | object>)) | undefined;
+                    readonly showLine?: (boolean | import('..').ShowLine) | undefined;
                     readonly animation?: boolean | undefined;
                     readonly nodeIndent?: number | undefined;
                     readonly renderNodeAmount?: number | undefined;
@@ -116,8 +114,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                 $slots: Readonly<{
                     [name: string]: import('vue').Slot<any> | undefined;
                 }>;
-                $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
-                $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
                 $host: Element | null;
                 $emit: (event: string, ...args: any[]) => void;
                 $el: any;
@@ -132,8 +130,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                     setExpand: (key: import('..').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
                     setExpandKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
                     setExpandAll: (value: boolean) => void;
-                    getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNode[];
-                    getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNodeKeyType[];
+                    getCheckedNodes: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNode[];
+                    getCheckedKeys: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNodeKeyType[];
                     getIndeterminateNodes: () => import('..').TreeNode[];
                     getSelectedNode: () => import('..').TreeNode | null;
                     getSelectedKey: () => import('..').TreeNodeKeyType | null;
@@ -149,12 +147,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                     append: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
                     prepend: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
                     remove: (removedKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-                    filter: (keyword: string, filterMethod?: import('..').FilterFunctionType | undefined) => void;
-                    showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+                    filter: (keyword: string, filterMethod?: import('..').FilterFunctionType) => void;
+                    showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
                     loadRootNodes: () => Promise<void>;
                     updateNode: (key: import('..').TreeNodeKeyType, newNode: import('..').ITreeNodeOptions) => void;
                     updateNodes: (newNodes: import('..').ITreeNodeOptions[]) => void;
-                    scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+                    scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
                 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
                     data: import('..').AnyPropsArrayType;
                     loading: boolean;
@@ -167,7 +165,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                     defaultExpandedKeys: import('..').TreeNodeKeyType[];
                     checkable: boolean;
                     emptyText: string;
-                    ignoreMode: "none" | "children" | "parents";
+                    ignoreMode: import('..').IgnoreType;
                     filteredNodeCheckable: boolean;
                     expandOnFilter: boolean;
                     showLeftArrow: boolean;
@@ -187,25 +185,25 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                     nodeMinHeight: number;
                     bufferNodeAmount: number;
                 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-                    created?: ((() => void) | (() => void)[]) | undefined;
-                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
-                    mounted?: ((() => void) | (() => void)[]) | undefined;
-                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-                    updated?: ((() => void) | (() => void)[]) | undefined;
-                    activated?: ((() => void) | (() => void)[]) | undefined;
-                    deactivated?: ((() => void) | (() => void)[]) | undefined;
-                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-                    destroyed?: ((() => void) | (() => void)[]) | undefined;
-                    unmounted?: ((() => void) | (() => void)[]) | undefined;
-                    renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
-                    renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
-                    errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                 };
                 $forceUpdate: () => void;
                 $nextTick: typeof import('vue').nextTick;
-                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
             } & Readonly<{
                 data: import('..').AnyPropsArrayType;
                 loading: boolean;
@@ -218,7 +216,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                 defaultExpandedKeys: import('..').TreeNodeKeyType[];
                 checkable: boolean;
                 emptyText: string;
-                ignoreMode: "none" | "children" | "parents";
+                ignoreMode: import('..').IgnoreType;
                 filteredNodeCheckable: boolean;
                 expandOnFilter: boolean;
                 showLeftArrow: boolean;
@@ -248,8 +246,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                 setExpand: (key: import('..').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
                 setExpandKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
                 setExpandAll: (value: boolean) => void;
-                getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNode[];
-                getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNodeKeyType[];
+                getCheckedNodes: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNode[];
+                getCheckedKeys: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNodeKeyType[];
                 getIndeterminateNodes: () => import('..').TreeNode[];
                 getSelectedNode: () => import('..').TreeNode | null;
                 getSelectedKey: () => import('..').TreeNodeKeyType | null;
@@ -265,12 +263,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
                 append: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
                 prepend: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
                 remove: (removedKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-                filter: (keyword: string, filterMethod?: import('..').FilterFunctionType | undefined) => void;
-                showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+                filter: (keyword: string, filterMethod?: import('..').FilterFunctionType) => void;
+                showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
                 loadRootNodes: () => Promise<void>;
                 updateNode: (key: import('..').TreeNodeKeyType, newNode: import('..').ITreeNodeOptions) => void;
                 updateNodes: (newNodes: import('..').ITreeNodeOptions[]) => void;
-                scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+                scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
             }> & {} & import('vue').ComponentCustomProperties & {} & {
                 $slots: {
                     node?(_: {
@@ -290,18 +288,18 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
         }>;
-        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
-        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
         $host: Element | null;
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<import('../tree-search').TreeSearchProps> & Readonly<{}>, {
             clearKeyword: () => void;
             getKeyword: () => string;
-            search: (keyword1?: string | undefined) => Promise<void>;
-            filter: (keyword: string, filterMethod?: import('..').FilterFunctionType | undefined) => void;
+            search: (keyword1?: string) => Promise<void>;
+            filter: (keyword: string, filterMethod?: import('..').FilterFunctionType) => void;
             remove: (removedKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+            scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
             insertBefore: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
             append: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
             prepend: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
@@ -315,8 +313,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
             setExpand: (key: import('..').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
             setExpandKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
             setExpandAll: (value: boolean) => void;
-            getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNode[];
-            getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNodeKeyType[];
+            getCheckedNodes: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNode[];
+            getCheckedKeys: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNodeKeyType[];
             getIndeterminateNodes: () => import('..').TreeNode[];
             getSelectedNode: () => import('..').TreeNode | null;
             getSelectedKey: () => import('..').TreeNodeKeyType | null;
@@ -328,7 +326,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
             getFlatData: () => import('..').TreeNode[];
             getNodesCount: () => number;
             insertAfter: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+            showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
             loadRootNodes: () => Promise<void>;
             updateNode: (key: import('..').TreeNodeKeyType, newNode: import('..').ITreeNodeOptions) => void;
             updateNodes: (newNodes: import('..').ITreeNodeOptions[]) => void;
@@ -347,7 +345,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
             checkable: boolean;
             showFooter: boolean;
             emptyText: string;
-            ignoreMode: "none" | "children" | "parents";
+            ignoreMode: import('..').IgnoreType;
             filteredNodeCheckable: boolean;
             expandOnFilter: boolean;
             showLeftArrow: boolean;
@@ -373,25 +371,25 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
             searchRemote: boolean;
             searchDebounceTime: number;
         }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-            created?: ((() => void) | (() => void)[]) | undefined;
-            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-            mounted?: ((() => void) | (() => void)[]) | undefined;
-            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-            updated?: ((() => void) | (() => void)[]) | undefined;
-            activated?: ((() => void) | (() => void)[]) | undefined;
-            deactivated?: ((() => void) | (() => void)[]) | undefined;
-            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-            destroyed?: ((() => void) | (() => void)[]) | undefined;
-            unmounted?: ((() => void) | (() => void)[]) | undefined;
-            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
-            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
-            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
         };
         $forceUpdate: () => void;
         $nextTick: typeof import('vue').nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
     } & Readonly<{
         data: import('..').AnyPropsArrayType;
         loading: boolean;
@@ -407,7 +405,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
         checkable: boolean;
         showFooter: boolean;
         emptyText: string;
-        ignoreMode: "none" | "children" | "parents";
+        ignoreMode: import('..').IgnoreType;
         filteredNodeCheckable: boolean;
         expandOnFilter: boolean;
         showLeftArrow: boolean;
@@ -435,10 +433,10 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
     }> & Omit<Readonly<import('../tree-search').TreeSearchProps> & Readonly<{}>, "filter" | "search" | "remove" | "scrollTo" | "insertBefore" | "append" | "prepend" | "clearSelected" | "setData" | "setChecked" | "setCheckedKeys" | "checkAll" | "clearChecked" | "setSelected" | "setExpand" | "setExpandKeys" | "setExpandAll" | "getCheckedNodes" | "getCheckedKeys" | "getIndeterminateNodes" | "getSelectedNode" | "getSelectedKey" | "getExpandNodes" | "getExpandKeys" | "getCurrentVisibleNodes" | "getNode" | "getTreeData" | "getFlatData" | "getNodesCount" | "insertAfter" | "showCheckedNodes" | "loadRootNodes" | "updateNode" | "updateNodes" | ("data" | "loading" | "searchPlaceholder" | "checkedButtonText" | "draggable" | "separator" | "keyField" | "cascade" | "defaultExpandAll" | "expandedKeys" | "defaultExpandedKeys" | "checkable" | "showFooter" | "emptyText" | "ignoreMode" | "filteredNodeCheckable" | "expandOnFilter" | "showLeftArrow" | "showRightArrow" | "selectable" | "titleField" | "showUnloadCheckedNodes" | "unloadDataList" | "enableLeafOnly" | "disableAll" | "droppable" | "beforeDropMethod" | "autoLoad" | "unselectOnClick" | "nodeIndent" | "renderNodeAmount" | "nodeMinHeight" | "bufferNodeAmount" | "showCheckAll" | "showCheckedButton" | "searchLength" | "searchDisabled" | "searchRemote" | "searchDebounceTime") | "clearKeyword" | "getKeyword"> & import('vue').ShallowUnwrapRef<{
         clearKeyword: () => void;
         getKeyword: () => string;
-        search: (keyword1?: string | undefined) => Promise<void>;
-        filter: (keyword: string, filterMethod?: import('..').FilterFunctionType | undefined) => void;
+        search: (keyword1?: string) => Promise<void>;
+        filter: (keyword: string, filterMethod?: import('..').FilterFunctionType) => void;
         remove: (removedKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+        scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
         insertBefore: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
         append: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
         prepend: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
@@ -452,8 +450,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
         setExpand: (key: import('..').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
         setExpandKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
         setExpandAll: (value: boolean) => void;
-        getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNode[];
-        getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNodeKeyType[];
+        getCheckedNodes: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNode[];
+        getCheckedKeys: (ignoreMode?: import('..').IgnoreType) => import('..').TreeNodeKeyType[];
         getIndeterminateNodes: () => import('..').TreeNode[];
         getSelectedNode: () => import('..').TreeNode | null;
         getSelectedKey: () => import('..').TreeNodeKeyType | null;
@@ -465,7 +463,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
         getFlatData: () => import('..').TreeNode[];
         getNodesCount: () => number;
         insertAfter: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+        showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
         loadRootNodes: () => Promise<void>;
         updateNode: (key: import('..').TreeNodeKeyType, newNode: import('..').ITreeNodeOptions) => void;
         updateNodes: (newNodes: import('..').ITreeNodeOptions[]) => void;
@@ -478,231 +476,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
     }) | null>>;
     setTreeData: (data: TreeOption[]) => void;
     getTreeData: () => TreeOption[];
-    instance: () => ({
-        $: import('vue').ComponentInternalInstance;
-        $data: {};
-        $props: {
-            readonly showLeftArrow?: boolean | undefined;
-            readonly showRightArrow?: boolean | undefined;
-            readonly data?: import('..').AnyPropsArrayType | undefined;
-            readonly emptyText?: string | undefined;
-            readonly modelValue?: import('..').TreeVModelType | undefined;
-            readonly selectable?: boolean | undefined;
-            readonly checkable?: boolean | undefined;
-            readonly separator?: string | undefined;
-            readonly ignoreMode?: "none" | "children" | "parents" | undefined;
-            readonly titleField?: string | undefined;
-            readonly keyField?: string | undefined;
-            readonly filterMethod?: import('..').FilterFunctionType | undefined;
-            readonly showUnloadCheckedNodes?: boolean | undefined;
-            readonly unloadDataList?: import('..').AnyPropsArrayType | undefined;
-            readonly load?: import('..').LoadFn | undefined;
-            readonly filteredNodeCheckable?: boolean | undefined;
-            readonly cascade?: boolean | undefined;
-            readonly enableLeafOnly?: boolean | undefined;
-            readonly disableAll?: boolean | undefined;
-            readonly defaultExpandAll?: boolean | undefined;
-            readonly defaultExpandedKeys?: import('..').TreeNodeKeyType[] | undefined;
-            readonly expandedKeys?: import('..').TreeNodeKeyType[] | undefined;
-            readonly draggable?: boolean | undefined;
-            readonly droppable?: boolean | undefined;
-            readonly beforeDropMethod?: ((dragKey: import('..').TreeNodeKeyType, dropKey: import('..').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean) | undefined;
-            readonly autoLoad?: boolean | undefined;
-            readonly render?: ((node: import('..').TreeNode) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-                [key: string]: any;
-            }>) | undefined;
-            readonly expandOnFilter?: boolean | undefined;
-            readonly unselectOnClick?: boolean | undefined;
-            readonly loading?: boolean | undefined;
-            readonly nodeClassName?: string | object | (string | object)[] | ((node: import('..').TreeNode) => string | object | (string | object)[]) | undefined;
-            readonly showLine?: boolean | import('..').ShowLine | undefined;
-            readonly animation?: boolean | undefined;
-            readonly nodeIndent?: number | undefined;
-            readonly renderNodeAmount?: number | undefined;
-            readonly nodeMinHeight?: number | undefined;
-            readonly bufferNodeAmount?: number | undefined;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        } & {
-            scrollArea: HTMLDivElement;
-        };
-        $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
-        }>;
-        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
-        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
-        $host: Element | null;
-        $emit: (event: string, ...args: any[]) => void;
-        $el: any;
-        $options: import('vue').ComponentOptionsBase<Readonly<import('..').TreeProps> & Readonly<{}>, {
-            setData: (data: import('..').AnyPropsArrayType) => void;
-            setChecked: (key: import('..').TreeNodeKeyType, value: boolean) => void;
-            setCheckedKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
-            checkAll: () => void;
-            clearChecked: () => void;
-            setSelected: (key: import('..').TreeNodeKeyType, value: boolean) => void;
-            clearSelected: () => void;
-            setExpand: (key: import('..').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
-            setExpandKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
-            setExpandAll: (value: boolean) => void;
-            getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNode[];
-            getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNodeKeyType[];
-            getIndeterminateNodes: () => import('..').TreeNode[];
-            getSelectedNode: () => import('..').TreeNode | null;
-            getSelectedKey: () => import('..').TreeNodeKeyType | null;
-            getExpandNodes: () => import('..').TreeNode[];
-            getExpandKeys: () => import('..').TreeNodeKeyType[];
-            getCurrentVisibleNodes: () => import('..').TreeNode[];
-            getNode: (key: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            getTreeData: () => import('..').TreeNode[];
-            getFlatData: () => import('..').TreeNode[];
-            getNodesCount: () => number;
-            insertBefore: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            insertAfter: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            append: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            prepend: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            remove: (removedKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-            filter: (keyword: string, filterMethod?: import('..').FilterFunctionType | undefined) => void;
-            showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
-            loadRootNodes: () => Promise<void>;
-            updateNode: (key: import('..').TreeNodeKeyType, newNode: import('..').ITreeNodeOptions) => void;
-            updateNodes: (newNodes: import('..').ITreeNodeOptions[]) => void;
-            scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
-        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
-            data: import('..').AnyPropsArrayType;
-            loading: boolean;
-            draggable: boolean;
-            separator: string;
-            keyField: string;
-            cascade: boolean;
-            defaultExpandAll: boolean;
-            expandedKeys: import('..').TreeNodeKeyType[];
-            defaultExpandedKeys: import('..').TreeNodeKeyType[];
-            checkable: boolean;
-            emptyText: string;
-            ignoreMode: "none" | "children" | "parents";
-            filteredNodeCheckable: boolean;
-            expandOnFilter: boolean;
-            showLeftArrow: boolean;
-            showRightArrow: boolean;
-            selectable: boolean;
-            titleField: string;
-            showUnloadCheckedNodes: boolean;
-            unloadDataList: import('..').AnyPropsArrayType;
-            enableLeafOnly: boolean;
-            disableAll: boolean;
-            droppable: boolean;
-            beforeDropMethod: (dragKey: import('..').TreeNodeKeyType, dropKey: import('..').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
-            autoLoad: boolean;
-            unselectOnClick: boolean;
-            nodeIndent: number;
-            renderNodeAmount: number;
-            nodeMinHeight: number;
-            bufferNodeAmount: number;
-        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-            created?: ((() => void) | (() => void)[]) | undefined;
-            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-            mounted?: ((() => void) | (() => void)[]) | undefined;
-            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-            updated?: ((() => void) | (() => void)[]) | undefined;
-            activated?: ((() => void) | (() => void)[]) | undefined;
-            deactivated?: ((() => void) | (() => void)[]) | undefined;
-            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-            destroyed?: ((() => void) | (() => void)[]) | undefined;
-            unmounted?: ((() => void) | (() => void)[]) | undefined;
-            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
-            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
-            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof import('vue').nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
-    } & Readonly<{
-        data: import('..').AnyPropsArrayType;
-        loading: boolean;
-        draggable: boolean;
-        separator: string;
-        keyField: string;
-        cascade: boolean;
-        defaultExpandAll: boolean;
-        expandedKeys: import('..').TreeNodeKeyType[];
-        defaultExpandedKeys: import('..').TreeNodeKeyType[];
-        checkable: boolean;
-        emptyText: string;
-        ignoreMode: "none" | "children" | "parents";
-        filteredNodeCheckable: boolean;
-        expandOnFilter: boolean;
-        showLeftArrow: boolean;
-        showRightArrow: boolean;
-        selectable: boolean;
-        titleField: string;
-        showUnloadCheckedNodes: boolean;
-        unloadDataList: import('..').AnyPropsArrayType;
-        enableLeafOnly: boolean;
-        disableAll: boolean;
-        droppable: boolean;
-        beforeDropMethod: (dragKey: import('..').TreeNodeKeyType, dropKey: import('..').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
-        autoLoad: boolean;
-        unselectOnClick: boolean;
-        nodeIndent: number;
-        renderNodeAmount: number;
-        nodeMinHeight: number;
-        bufferNodeAmount: number;
-    }> & Omit<Readonly<import('..').TreeProps> & Readonly<{}>, "filter" | "remove" | "scrollTo" | "insertBefore" | "append" | "prepend" | "clearSelected" | "setData" | "setChecked" | "setCheckedKeys" | "checkAll" | "clearChecked" | "setSelected" | "setExpand" | "setExpandKeys" | "setExpandAll" | "getCheckedNodes" | "getCheckedKeys" | "getIndeterminateNodes" | "getSelectedNode" | "getSelectedKey" | "getExpandNodes" | "getExpandKeys" | "getCurrentVisibleNodes" | "getNode" | "getTreeData" | "getFlatData" | "getNodesCount" | "insertAfter" | "showCheckedNodes" | "loadRootNodes" | "updateNode" | "updateNodes" | ("data" | "loading" | "draggable" | "separator" | "keyField" | "cascade" | "defaultExpandAll" | "expandedKeys" | "defaultExpandedKeys" | "checkable" | "emptyText" | "ignoreMode" | "filteredNodeCheckable" | "expandOnFilter" | "showLeftArrow" | "showRightArrow" | "selectable" | "titleField" | "showUnloadCheckedNodes" | "unloadDataList" | "enableLeafOnly" | "disableAll" | "droppable" | "beforeDropMethod" | "autoLoad" | "unselectOnClick" | "nodeIndent" | "renderNodeAmount" | "nodeMinHeight" | "bufferNodeAmount")> & import('vue').ShallowUnwrapRef<{
-        setData: (data: import('..').AnyPropsArrayType) => void;
-        setChecked: (key: import('..').TreeNodeKeyType, value: boolean) => void;
-        setCheckedKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
-        checkAll: () => void;
-        clearChecked: () => void;
-        setSelected: (key: import('..').TreeNodeKeyType, value: boolean) => void;
-        clearSelected: () => void;
-        setExpand: (key: import('..').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
-        setExpandKeys: (keys: import('..').TreeNodeKeyType[], value: boolean) => void;
-        setExpandAll: (value: boolean) => void;
-        getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNode[];
-        getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('..').TreeNodeKeyType[];
-        getIndeterminateNodes: () => import('..').TreeNode[];
-        getSelectedNode: () => import('..').TreeNode | null;
-        getSelectedKey: () => import('..').TreeNodeKeyType | null;
-        getExpandNodes: () => import('..').TreeNode[];
-        getExpandKeys: () => import('..').TreeNodeKeyType[];
-        getCurrentVisibleNodes: () => import('..').TreeNode[];
-        getNode: (key: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        getTreeData: () => import('..').TreeNode[];
-        getFlatData: () => import('..').TreeNode[];
-        getNodesCount: () => number;
-        insertBefore: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        insertAfter: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, referenceKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        append: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        prepend: (insertedNode: import('..').TreeNodeKeyType | import('..').ITreeNodeOptions, parentKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        remove: (removedKey: import('..').TreeNodeKeyType) => import('..').TreeNode | null;
-        filter: (keyword: string, filterMethod?: import('..').FilterFunctionType | undefined) => void;
-        showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
-        loadRootNodes: () => Promise<void>;
-        updateNode: (key: import('..').TreeNodeKeyType, newNode: import('..').ITreeNodeOptions) => void;
-        updateNodes: (newNodes: import('..').ITreeNodeOptions[]) => void;
-        scrollTo: (key: import('..').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
-    }> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            node?(_: {
-                node: import('..').TreeNode;
-            }): any;
-            node?(_: {
-                node: import('..').TreeNode;
-            }): any;
-            node?(_: {
-                node: import('..').TreeNode;
-            }): any;
-            empty?(_: {}): any;
-            loading?(_: {}): any;
-        };
-    }) | null;
+    instance: () => import('..').TreeInstance | null;
     load: () => Promise<void>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     select: (args_0: import('..').TreeNode) => any;
@@ -745,7 +519,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Ba
 }>, {
     transform: import('./interface').TransformOption | null;
     immediate: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, any, any>, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, any, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/dist/components/basic-tree/BasicTree.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BasicTree.vue.d.ts","sourceRoot":"","sources":["../../../src/components/basic-tree/BasicTree.vue"],"names":[],"mappings":"AAmIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAO1C,OAAO,KAAK,EAAkB,cAAc,EAAkB,MAAM,aAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2MjF,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"BasicTree.vue.d.ts","sourceRoot":"","sources":["../../../src/components/basic-tree/BasicTree.vue"],"names":[],"mappings":"AAmIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAO1C,OAAO,KAAK,EAAkB,cAAc,EAAkB,MAAM,aAAa,CAAA;AA+GjF,iBAAS,cAAc,QA4DtB;AAmBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAgC4vf,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EArBr4f,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/basic-tree/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/components/basic-tree/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AAEvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,gBAAgB,CAAwB,CAAA;AAEhF,eAAO,MAAM,sBAAsB,UAAW,gBAAgB,SAE7D,CAAA;AAED,eAAO,MAAM,mBAAmB,wBAE/B,CAAA"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/components/basic-tree/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AAEvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,gBAAgB,CAAwB,CAAA;AAEhF,eAAO,MAAM,sBAAsB,GAAI,OAAO,gBAAgB,SAE7D,CAAA;AAED,eAAO,MAAM,mBAAmB,QACC,gBAChC,CAAA"}