@maxax/ui 1.1.39 → 1.1.41

package/dist/components/tree-drop/TreeDrop.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeDrop.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-drop/TreeDrop.vue"],"names":[],"mappings":"AAGA;AAqTA,OAAO,EAAY,QAAQ,EAA6C,MAAM,KAAK,CAAA;AACnF,OAAO,KAAK,EAAqB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAM7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqbhD,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":"TreeDrop.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-drop/TreeDrop.vue"],"names":[],"mappings":"AAGA;AAqTA,OAAO,EAAY,QAAQ,EAA6C,MAAM,KAAK,CAAA;AACnF,OAAO,KAAK,EAAqB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAM7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAqQhD,iBAAS,cAAc;WA8HT,OAAO,IAA6B;8CAjBqC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE7D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YACH,GAAG;uBACL,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAmFqB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAjExK;AAiCD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA+B8B,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OArBvK,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/tree-drop/composable/use-tree-drop-cls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tree-drop-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-drop/composable/use-tree-drop-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,UAClB,aAAa,WACX;IACP,eAAe,EAAE,IAAI,OAAO,CAAC,CAAA;IAC7B,YAAY,EAAE,IAAI,MAAM,CAAC,CAAA;IACzB,aAAa,EAAE,IAAI,MAAM,CAAC,CAAA;CAC3B;;;;;;;;;;;;;;CAuEF,CAAA"}
+{"version":3,"file":"use-tree-drop-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-drop/composable/use-tree-drop-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,GACzB,OAAO,aAAa,EACpB,SAAS;IACP,eAAe,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAC3B;;;;;;;;;;;;;;CAuEF,CAAA"}

package/dist/components/tree-node/TreeNode.vue.d.ts

@@ -1,12 +1,22 @@
 import { TreeNode } from '../tree/store';
 import { TreeNodeProps } from './interface';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TreeNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            node: TreeNode;
+        }): any;
+    };
+    refs: {
+        nodeBody: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TreeNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     nodeBody: HTMLDivElement;
-}, HTMLDivElement>, {
-    default?(_: {
-        node: TreeNode;
-    }): any;
-}>;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {

package/dist/components/tree-node/TreeNode.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeNode.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-node/TreeNode.vue"],"names":[],"mappings":"AAGA;AAoRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;;;;;;;;AAuZhD,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"TreeNode.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-node/TreeNode.vue"],"names":[],"mappings":"AAGA;AAoRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AA6MhD,iBAAS,cAAc;WAqJT,OAAO,IAA6B;;;;YAXrB,GAAG;;;;;;EAgB/B;AAqCD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;kBASnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/tree-node/composable/use-tree-node-cls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tree-node-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-node/composable/use-tree-node-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,UAClB,aAAa,gBACN;IACZ,YAAY,EAAE,IAAI,OAAO,CAAC,CAAA;IAC1B,cAAc,EAAE,IAAI,OAAO,CAAC,CAAA;IAC5B,aAAa,EAAE,IAAI,OAAO,CAAC,CAAA;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGF,CAAA"}
+{"version":3,"file":"use-tree-node-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-node/composable/use-tree-node-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,GACzB,OAAO,aAAa,EACpB,cAAc;IACZ,YAAY,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC1B,cAAc,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC5B,aAAa,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGF,CAAA"}

package/dist/components/tree-search/TreeSearch.vue.d.ts

@@ -5,13 +5,248 @@ declare function clearKeyword(): void;
 declare function getKeyword(): string;
 /** 执行搜索 */
 declare function search(keyword1?: string): Promise<void>;
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TreeSearchProps, {
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: any) => any>> & {
+        'search-input'?(_: {}): any;
+        actions?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        treeRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly showLeftArrow?: boolean | undefined;
+                readonly showRightArrow?: boolean | undefined;
+                readonly data?: import('../tree').AnyPropsArrayType | undefined;
+                readonly emptyText?: string | undefined;
+                readonly modelValue?: import('../tree').TreeVModelType | undefined;
+                readonly selectable?: boolean | undefined;
+                readonly checkable?: boolean | undefined;
+                readonly separator?: string | undefined;
+                readonly ignoreMode?: import('../tree').IgnoreType | undefined;
+                readonly titleField?: string | undefined;
+                readonly keyField?: string | undefined;
+                readonly filterMethod?: import('../tree').FilterFunctionType | undefined;
+                readonly showUnloadCheckedNodes?: boolean | undefined;
+                readonly unloadDataList?: import('../tree').AnyPropsArrayType | undefined;
+                readonly load?: import('../tree').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('../tree').TreeNodeKeyType[] | undefined;
+                readonly expandedKeys?: import('../tree').TreeNodeKeyType[] | undefined;
+                readonly draggable?: boolean | undefined;
+                readonly droppable?: boolean | undefined;
+                readonly beforeDropMethod?: ((dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean) | undefined;
+                readonly autoLoad?: boolean | undefined;
+                readonly render?: ((node: TreeNode) => import('vue').VNode) | undefined;
+                readonly expandOnFilter?: boolean | undefined;
+                readonly unselectOnClick?: boolean | undefined;
+                readonly loading?: boolean | undefined;
+                readonly nodeClassName?: (string | object | Array<string | object> | ((node: TreeNode) => string | object | Array<string | object>)) | undefined;
+                readonly showLine?: (boolean | import('../tree').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 | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('../tree').TreeProps> & Readonly<{}>, {
+                setData: (data: import('../tree').AnyPropsArrayType) => void;
+                setChecked: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+                setCheckedKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+                checkAll: () => void;
+                clearChecked: () => void;
+                setSelected: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+                clearSelected: () => void;
+                setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+                setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+                setExpandAll: (value: boolean) => void;
+                getCheckedNodes: (ignoreMode?: import('../tree').IgnoreType) => TreeNode[];
+                getCheckedKeys: (ignoreMode?: import('../tree').IgnoreType) => import('../tree').TreeNodeKeyType[];
+                getIndeterminateNodes: () => TreeNode[];
+                getSelectedNode: () => TreeNode | null;
+                getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
+                getExpandNodes: () => TreeNode[];
+                getExpandKeys: () => import('../tree').TreeNodeKeyType[];
+                getCurrentVisibleNodes: () => TreeNode[];
+                getNode: (key: import('../tree').TreeNodeKeyType) => TreeNode | null;
+                getTreeData: () => TreeNode[];
+                getFlatData: () => TreeNode[];
+                getNodesCount: () => number;
+                insertBefore: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+                insertAfter: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+                append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+                prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+                remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+                filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType) => void;
+                showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+                loadRootNodes: () => Promise<void>;
+                updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
+                updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
+                scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                data: import('../tree').AnyPropsArrayType;
+                loading: boolean;
+                draggable: boolean;
+                separator: string;
+                keyField: string;
+                cascade: boolean;
+                defaultExpandAll: boolean;
+                expandedKeys: import('../tree').TreeNodeKeyType[];
+                defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
+                checkable: boolean;
+                emptyText: string;
+                ignoreMode: import('../tree').IgnoreType;
+                filteredNodeCheckable: boolean;
+                expandOnFilter: boolean;
+                showLeftArrow: boolean;
+                showRightArrow: boolean;
+                selectable: boolean;
+                titleField: string;
+                showUnloadCheckedNodes: boolean;
+                unloadDataList: import('../tree').AnyPropsArrayType;
+                enableLeafOnly: boolean;
+                disableAll: boolean;
+                droppable: boolean;
+                beforeDropMethod: (dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').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)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            data: import('../tree').AnyPropsArrayType;
+            loading: boolean;
+            draggable: boolean;
+            separator: string;
+            keyField: string;
+            cascade: boolean;
+            defaultExpandAll: boolean;
+            expandedKeys: import('../tree').TreeNodeKeyType[];
+            defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
+            checkable: boolean;
+            emptyText: string;
+            ignoreMode: import('../tree').IgnoreType;
+            filteredNodeCheckable: boolean;
+            expandOnFilter: boolean;
+            showLeftArrow: boolean;
+            showRightArrow: boolean;
+            selectable: boolean;
+            titleField: string;
+            showUnloadCheckedNodes: boolean;
+            unloadDataList: import('../tree').AnyPropsArrayType;
+            enableLeafOnly: boolean;
+            disableAll: boolean;
+            droppable: boolean;
+            beforeDropMethod: (dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
+            autoLoad: boolean;
+            unselectOnClick: boolean;
+            nodeIndent: number;
+            renderNodeAmount: number;
+            nodeMinHeight: number;
+            bufferNodeAmount: number;
+        }> & Omit<Readonly<import('../tree').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('../tree').AnyPropsArrayType) => void;
+            setChecked: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+            setCheckedKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+            checkAll: () => void;
+            clearChecked: () => void;
+            setSelected: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+            clearSelected: () => void;
+            setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+            setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+            setExpandAll: (value: boolean) => void;
+            getCheckedNodes: (ignoreMode?: import('../tree').IgnoreType) => TreeNode[];
+            getCheckedKeys: (ignoreMode?: import('../tree').IgnoreType) => import('../tree').TreeNodeKeyType[];
+            getIndeterminateNodes: () => TreeNode[];
+            getSelectedNode: () => TreeNode | null;
+            getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
+            getExpandNodes: () => TreeNode[];
+            getExpandKeys: () => import('../tree').TreeNodeKeyType[];
+            getCurrentVisibleNodes: () => TreeNode[];
+            getNode: (key: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            getTreeData: () => TreeNode[];
+            getFlatData: () => TreeNode[];
+            getNodesCount: () => number;
+            insertBefore: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            insertAfter: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType) => void;
+            showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+            loadRootNodes: () => Promise<void>;
+            updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
+            updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
+            scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                node?(_: {
+                    node: TreeNode;
+                }): any;
+                node?(_: {
+                    node: TreeNode;
+                }): any;
+                node?(_: {
+                    node: TreeNode;
+                }): any;
+                empty?(_: {}): any;
+                loading?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TreeSearchProps, {
     clearKeyword: typeof clearKeyword;
     getKeyword: typeof getKeyword;
     search: typeof search;
-    filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType | undefined) => void;
+    filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType) => void;
     remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
-    scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+    scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
     insertBefore: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
     append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
     prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
@@ -25,8 +260,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
     setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
     setExpandAll: (value: boolean) => void;
-    getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-    getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('../tree').TreeNodeKeyType[];
+    getCheckedNodes: (ignoreMode?: import('../tree').IgnoreType) => TreeNode[];
+    getCheckedKeys: (ignoreMode?: import('../tree').IgnoreType) => import('../tree').TreeNodeKeyType[];
     getIndeterminateNodes: () => TreeNode[];
     getSelectedNode: () => TreeNode | null;
     getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
@@ -38,15 +273,13 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     getFlatData: () => TreeNode[];
     getNodesCount: () => number;
     insertAfter: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
-    showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+    showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
     loadRootNodes: () => Promise<void>;
     updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
     updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeSearchProps> & Readonly<{}>, {
     data: import('../tree').AnyPropsArrayType;
     loading: boolean;
-    searchPlaceholder: string;
-    checkedButtonText: string;
     draggable: boolean;
     separator: string;
     keyField: string;
@@ -57,7 +290,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     checkable: boolean;
     showFooter: boolean;
     emptyText: string;
-    ignoreMode: "none" | "children" | "parents";
+    ignoreMode: import('../tree').IgnoreType;
     filteredNodeCheckable: boolean;
     expandOnFilter: boolean;
     showLeftArrow: boolean;
@@ -76,8 +309,10 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     renderNodeAmount: number;
     nodeMinHeight: number;
     bufferNodeAmount: number;
+    searchPlaceholder: string;
     showCheckAll: boolean;
     showCheckedButton: boolean;
+    checkedButtonText: string;
     searchLength: number;
     searchDisabled: boolean;
     searchRemote: boolean;
@@ -95,7 +330,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             readonly selectable?: boolean | undefined;
             readonly checkable?: boolean | undefined;
             readonly separator?: string | undefined;
-            readonly ignoreMode?: "none" | "children" | "parents" | undefined;
+            readonly ignoreMode?: import('../tree').IgnoreType | undefined;
             readonly titleField?: string | undefined;
             readonly keyField?: string | undefined;
             readonly filterMethod?: import('../tree').FilterFunctionType | undefined;
@@ -113,14 +348,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             readonly droppable?: boolean | undefined;
             readonly beforeDropMethod?: ((dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean) | undefined;
             readonly autoLoad?: boolean | undefined;
-            readonly render?: ((node: TreeNode) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-                [key: string]: any;
-            }>) | undefined;
+            readonly render?: ((node: TreeNode) => import('vue').VNode) | undefined;
             readonly expandOnFilter?: boolean | undefined;
             readonly unselectOnClick?: boolean | undefined;
             readonly loading?: boolean | undefined;
-            readonly nodeClassName?: string | object | (string | object)[] | ((node: TreeNode) => string | object | (string | object)[]) | undefined;
-            readonly showLine?: boolean | import('../tree').ShowLine | undefined;
+            readonly nodeClassName?: (string | object | Array<string | object> | ((node: TreeNode) => string | object | Array<string | object>)) | undefined;
+            readonly showLine?: (boolean | import('../tree').ShowLine) | undefined;
             readonly animation?: boolean | undefined;
             readonly nodeIndent?: number | undefined;
             readonly renderNodeAmount?: number | undefined;
@@ -138,8 +371,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         $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;
@@ -154,8 +387,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
             setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
             setExpandAll: (value: boolean) => void;
-            getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-            getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('../tree').TreeNodeKeyType[];
+            getCheckedNodes: (ignoreMode?: import('../tree').IgnoreType) => TreeNode[];
+            getCheckedKeys: (ignoreMode?: import('../tree').IgnoreType) => import('../tree').TreeNodeKeyType[];
             getIndeterminateNodes: () => TreeNode[];
             getSelectedNode: () => TreeNode | null;
             getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
@@ -171,12 +404,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
             prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
             remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
-            filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType | undefined) => void;
-            showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+            filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType) => void;
+            showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
             loadRootNodes: () => Promise<void>;
             updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
             updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
-            scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+            scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
             data: import('../tree').AnyPropsArrayType;
             loading: boolean;
@@ -189,7 +422,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
             checkable: boolean;
             emptyText: string;
-            ignoreMode: "none" | "children" | "parents";
+            ignoreMode: import('../tree').IgnoreType;
             filteredNodeCheckable: boolean;
             expandOnFilter: boolean;
             showLeftArrow: boolean;
@@ -209,25 +442,25 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             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('../tree').AnyPropsArrayType;
         loading: boolean;
@@ -240,7 +473,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
         checkable: boolean;
         emptyText: string;
-        ignoreMode: "none" | "children" | "parents";
+        ignoreMode: import('../tree').IgnoreType;
         filteredNodeCheckable: boolean;
         expandOnFilter: boolean;
         showLeftArrow: boolean;
@@ -270,8 +503,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
         setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
         setExpandAll: (value: boolean) => void;
-        getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-        getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('../tree').TreeNodeKeyType[];
+        getCheckedNodes: (ignoreMode?: import('../tree').IgnoreType) => TreeNode[];
+        getCheckedKeys: (ignoreMode?: import('../tree').IgnoreType) => import('../tree').TreeNodeKeyType[];
         getIndeterminateNodes: () => TreeNode[];
         getSelectedNode: () => TreeNode | null;
         getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
@@ -287,12 +520,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
         prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
         remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
-        filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType | undefined) => void;
-        showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+        filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType) => void;
+        showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
         loadRootNodes: () => Promise<void>;
         updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
         updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
-        scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+        scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
     }> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             node?(_: {
@@ -308,11 +541,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             loading?(_: {}): any;
         };
     }) | null;
-}, any>, Partial<Record<string, (_: any) => any>> & {
-    'search-input'?(_: {}): any;
-    actions?(_: {}): any;
-    footer?(_: {}): 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/tree-search/TreeSearch.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeSearch.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-search/TreeSearch.vue"],"names":[],"mappings":"AAqRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAOvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AA2DlD,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED,cAAc;AACd,iBAAS,UAAU,IAAI,MAAM,CAE5B;AAUD,WAAW;AACX,iBAAS,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqSD,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":"TreeSearch.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-search/TreeSearch.vue"],"names":[],"mappings":"AAqRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAOvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AA2DlD,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED,cAAc;AACd,iBAAS,UAAU,IAAI,MAAM,CAE5B;AAUD,WAAW;AACX,iBAAS,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkChD;AA4HD,iBAAS,cAAc;WAqHT,OAAO,IAA6B;8CAfqC,GAAG;gCAEtD,GAAG;yBACV,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmFylK,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAnE9uK;AAmCD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+BomK,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OArB7uK,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/tree-search/composable/use-tree-search-cls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tree-search-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-search/composable/use-tree-search-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,eAAO,MAAM,gBAAgB,UACpB,eAAe,WACb;IACP,cAAc,EAAE;QACd,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,OAAO,CAAA;QACtB,QAAQ,EAAE,OAAO,CAAA;KAClB,CAAA;IACD,gBAAgB,EAAE,IAAI,OAAO,CAAC,CAAA;CAC/B;;;;;;;;;;;;;;;;;;CA6EF,CAAA"}
+{"version":3,"file":"use-tree-search-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-search/composable/use-tree-search-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,eAAO,MAAM,gBAAgB,GAC3B,OAAO,eAAe,EACtB,SAAS;IACP,cAAc,EAAE;QACd,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,OAAO,CAAA;QACtB,QAAQ,EAAE,OAAO,CAAA;KAClB,CAAA;IACD,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAC/B;;;;;;;;;;;;;;;;;;CA6EF,CAAA"}

package/dist/composable/use-dragable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-dragable.d.ts","sourceRoot":"","sources":["../../src/composable/use-dragable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI3C,eAAO,MAAM,YAAY,cAAe,IAAI,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,WAAW,GAAG,SAAS,CAAC,aAAa,YAAY,OAAO,CAAC,aAAa,YAAY,OAAO,CAAC;;CA4F5K,CAAA"}
+{"version":3,"file":"use-dragable.d.ts","sourceRoot":"","sources":["../../src/composable/use-dragable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI3C,eAAO,MAAM,YAAY,GAAI,WAAW,GAAG,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,SAAS,GAAG,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,WAAW,WAAW,CAAC,OAAO,CAAC,EAAE,WAAW,WAAW,CAAC,OAAO,CAAC;;CA4F5K,CAAA"}

package/dist/composable/use-locale.d.ts

@@ -1,4 +1,3 @@
-import { Ref } from 'vue';
-import { Locale, LocaleContext } from '../locale';
-export declare function useLocale(localeOverrides?: Ref<Locale | undefined>): LocaleContext;
+import { LocaleContext } from '../types';
+export declare function useLocale(): LocaleContext;
 //# sourceMappingURL=use-locale.d.ts.map

package/dist/composable/use-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-locale.d.ts","sourceRoot":"","sources":["../../src/composable/use-locale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAGtD,wBAAgB,SAAS,CAAC,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,aAAa,CAGlF"}
+{"version":3,"file":"use-locale.d.ts","sourceRoot":"","sources":["../../src/composable/use-locale.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,wBAAgB,SAAS,IAAI,aAAa,CAIzC"}

package/dist/composable/use-lockscreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-lockscreen.d.ts","sourceRoot":"","sources":["../../src/composable/use-lockscreen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGzD,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,kBAAkB,CAAA;CAExB;AAED,eAAO,MAAM,aAAa,YAAa,IAAI,OAAO,CAAC,YAAW,oBAAoB,SA+CjF,CAAA"}
+{"version":3,"file":"use-lockscreen.d.ts","sourceRoot":"","sources":["../../src/composable/use-lockscreen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGzD,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,kBAAkB,CAAA;CAExB;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,UAAS,oBAAyB,SA+CtF,CAAA"}

package/dist/composable/use-namespace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-namespace.d.ts","sourceRoot":"","sources":["../../src/composable/use-namespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAO9B,eAAO,MAAM,sBAAsB,wBAAyB,IAAI,MAAM,GAAG,SAAS,CAAC,sCAMlF,CAAA;AAgBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;;;;kBAMjE,MAAM;mBACL,MAAM;uBACF,MAAM,YAAY,MAAM;mBAC5B,MAAM,aAAa,MAAM;uBACrB,MAAM,aAAa,MAAM;wBACxB,MAAM,YAAY,MAAM,aAAa,MAAM;eAEpD,MAAM,WAAW,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,EAAE;qBAKrC,OAAO,MAAM,EAAE,MAAM,CAAC;0BAUjB,OAAO,MAAM,EAAE,MAAM,CAAC;uBAUzB,MAAM;4BACD,MAAM;EAkBtC;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"use-namespace.d.ts","sourceRoot":"","sources":["../../src/composable/use-namespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAO9B,eAAO,MAAM,sBAAsB,GAAI,qBAAqB,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,sCAMlF,CAAA;AAgBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;;;;kBAMjE,MAAM;mBACL,MAAM;uBACF,MAAM,YAAY,MAAM;mBAC5B,MAAM,aAAa,MAAM;uBACrB,MAAM,aAAa,MAAM;wBACxB,MAAM,YAAY,MAAM,aAAa,MAAM;eAEpD,MAAM,WAAW,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,EAAE;qBAKrC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;0BAUjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;uBAUzB,MAAM;4BACD,MAAM;EAkBtC;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/composable/use-responsive-observe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-responsive-observe.d.ts","sourceRoot":"","sources":["../../src/composable/use-responsive-observe.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAEnF,eAAO,MAAM,eAAe,EAAE,UAAU,EAAkD,CAAA;AAY1F,wBAAgB,oBAAoB;;;iBAUrB,cAAc;8BACD,cAAc,MAAM,mBAAmB,KAAK,GAAG;;;uBAGlD,SAAS;oBAKZ,aAAa,GAAG,MAAM;4BAOd,MAAM;;;;GAkCnC"}
+{"version":3,"file":"use-responsive-observe.d.ts","sourceRoot":"","sources":["../../src/composable/use-responsive-observe.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAEnF,eAAO,MAAM,eAAe,EAAE,UAAU,EAAkD,CAAA;AAY1F,wBAAgB,oBAAoB;mBAQT;QACnB,CAAC,IAAI,EAAE,MAAM,GAAG;YACd,GAAG,EAAE,cAAc,CAAA;YACnB,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,mBAAmB,KAAK,GAAG,CAAC,GAAG,IAAI,CAAA;SAC1E,CAAA;KACF;uBACkB,SAAS;oBAKZ,aAAa,GAAG,MAAM;4BAOd,MAAM;;;;GAkCnC"}

package/dist/composable/use-same-target.d.ts

@@ -1,4 +1,4 @@
-export declare const useSameTarget: (handleClick?: ((e: MouseEvent) => void) | undefined) => {
+export declare const useSameTarget: (handleClick?: (e: MouseEvent) => void) => {
     onClick: (e: MouseEvent) => void;
     onMousedown: (e: MouseEvent) => void;
     onMouseup: (e: MouseEvent) => void;

package/dist/composable/use-same-target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-same-target.d.ts","sourceRoot":"","sources":["../../src/composable/use-same-target.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,sBAAsB,UAAU,KAAK,IAAI;iBAU7C,UAAU;qBASN,UAAU;mBAIZ,UAAU;CAMjC,CAAA"}
+{"version":3,"file":"use-same-target.d.ts","sourceRoot":"","sources":["../../src/composable/use-same-target.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,GAAI,cAAc,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI;iBAU7C,UAAU;qBASN,UAAU;mBAIZ,UAAU;CAMjC,CAAA"}

package/dist/composable/use-z-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-z-index.d.ts","sourceRoot":"","sources":["../../src/composable/use-z-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAO5C,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAA;CAChB;AAMD,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,sBAAsB,CAAgC,CAAA;AAEtG,eAAO,MAAM,SAAS,qBAAsB,IAAI,MAAM,CAAC;;;;CAuBtD,CAAA"}
+{"version":3,"file":"use-z-index.d.ts","sourceRoot":"","sources":["../../src/composable/use-z-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAO5C,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAA;CAChB;AAMD,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,sBAAsB,CAAgC,CAAA;AAEtG,eAAO,MAAM,SAAS,GAAI,kBAAkB,GAAG,CAAC,MAAM,CAAC;;;;CAuBtD,CAAA"}