@maxax/ui 1.1.39 → 1.1.40

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

@@ -2,11 +2,578 @@ import { nextTick } from 'vue';
 import { TreeNodeKeyType } from '../tree/interface';
 import { TreeNode } from '../tree/store';
 import { TreeDropProps } from './interface';
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TreeDropProps, {
-    filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType | undefined) => void;
-    search: (keyword1?: string | undefined) => Promise<void>;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: any) => any>> & {
+        default?(_: {
+            checkedNodes: {
+                [x: string]: any;
+                _level: number;
+                checked: boolean;
+                selected: boolean;
+                indeterminate: boolean;
+                disabled: boolean;
+                expand: boolean;
+                visible: boolean;
+                _filterVisible: boolean;
+                _parent: /*elided*/ any | null;
+                children: /*elided*/ any[];
+                isLeaf: boolean;
+                _loading: boolean;
+                _loaded: boolean;
+                readonly _keyField: string;
+                readonly _remote: boolean;
+                setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
+            }[];
+            checkedKeys: TreeNodeKeyType[];
+            selectedNode?: {
+                [x: string]: any;
+                _level: number;
+                checked: boolean;
+                selected: boolean;
+                indeterminate: boolean;
+                disabled: boolean;
+                expand: boolean;
+                visible: boolean;
+                _filterVisible: boolean;
+                _parent: /*elided*/ any | null;
+                children: /*elided*/ any[];
+                isLeaf: boolean;
+                _loading: boolean;
+                _loaded: boolean;
+                readonly _keyField: string;
+                readonly _remote: boolean;
+                setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
+            } | undefined;
+            selectedKey?: TreeNodeKeyType | undefined;
+        }): any;
+        display?(_: {
+            checkedNodes: {
+                [x: string]: any;
+                _level: number;
+                checked: boolean;
+                selected: boolean;
+                indeterminate: boolean;
+                disabled: boolean;
+                expand: boolean;
+                visible: boolean;
+                _filterVisible: boolean;
+                _parent: /*elided*/ any | null;
+                children: /*elided*/ any[];
+                isLeaf: boolean;
+                _loading: boolean;
+                _loaded: boolean;
+                readonly _keyField: string;
+                readonly _remote: boolean;
+                setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
+            }[];
+            checkedKeys: TreeNodeKeyType[];
+            selectedNode?: {
+                [x: string]: any;
+                _level: number;
+                checked: boolean;
+                selected: boolean;
+                indeterminate: boolean;
+                disabled: boolean;
+                expand: boolean;
+                visible: boolean;
+                _filterVisible: boolean;
+                _parent: /*elided*/ any | null;
+                children: /*elided*/ any[];
+                isLeaf: boolean;
+                _loading: boolean;
+                _loaded: boolean;
+                readonly _keyField: string;
+                readonly _remote: boolean;
+                setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
+            } | undefined;
+            selectedKey?: TreeNodeKeyType | undefined;
+        }): any;
+        clear?(_: {}): any;
+    };
+    refs: {
+        referenceRef: HTMLDivElement;
+        dropdownRef: HTMLDivElement;
+        treeSearchRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly showLeftArrow?: boolean | undefined;
+                readonly showRightArrow?: boolean | undefined;
+                readonly data?: import('../tree/interface').AnyPropsArrayType | undefined;
+                readonly emptyText?: string | undefined;
+                readonly modelValue?: import('../tree/interface').TreeVModelType | undefined;
+                readonly selectable?: boolean | undefined;
+                readonly checkable?: boolean | undefined;
+                readonly separator?: string | undefined;
+                readonly ignoreMode?: import('../tree/interface').IgnoreType | undefined;
+                readonly titleField?: string | undefined;
+                readonly keyField?: string | undefined;
+                readonly filterMethod?: import('../tree/interface').FilterFunctionType | undefined;
+                readonly showUnloadCheckedNodes?: boolean | undefined;
+                readonly unloadDataList?: import('../tree/interface').AnyPropsArrayType | undefined;
+                readonly load?: import('../tree/interface').LoadFn | undefined;
+                readonly filteredNodeCheckable?: boolean | undefined;
+                readonly cascade?: boolean | undefined;
+                readonly enableLeafOnly?: boolean | undefined;
+                readonly disableAll?: boolean | undefined;
+                readonly defaultExpandAll?: boolean | undefined;
+                readonly defaultExpandedKeys?: TreeNodeKeyType[] | undefined;
+                readonly expandedKeys?: TreeNodeKeyType[] | undefined;
+                readonly draggable?: boolean | undefined;
+                readonly droppable?: boolean | undefined;
+                readonly beforeDropMethod?: ((dragKey: TreeNodeKeyType, dropKey: 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/interface').ShowLine) | undefined;
+                readonly animation?: boolean | undefined;
+                readonly nodeIndent?: number | undefined;
+                readonly renderNodeAmount?: number | undefined;
+                readonly nodeMinHeight?: number | undefined;
+                readonly bufferNodeAmount?: number | undefined;
+                readonly searchPlaceholder?: string | undefined;
+                readonly showCheckAll?: boolean | undefined;
+                readonly showCheckedButton?: boolean | undefined;
+                readonly checkedButtonText?: string | undefined;
+                readonly showFooter?: boolean | undefined;
+                readonly searchMethod?: ((keyword: string) => void | Promise<void>) | undefined;
+                readonly searchLength?: number | undefined;
+                readonly searchDisabled?: boolean | undefined;
+                readonly searchRemote?: boolean | undefined;
+                readonly searchDebounceTime?: number | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                treeRef: ({
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly showLeftArrow?: boolean | undefined;
+                        readonly showRightArrow?: boolean | undefined;
+                        readonly data?: import('../tree/interface').AnyPropsArrayType | undefined;
+                        readonly emptyText?: string | undefined;
+                        readonly modelValue?: import('../tree/interface').TreeVModelType | undefined;
+                        readonly selectable?: boolean | undefined;
+                        readonly checkable?: boolean | undefined;
+                        readonly separator?: string | undefined;
+                        readonly ignoreMode?: import('../tree/interface').IgnoreType | undefined;
+                        readonly titleField?: string | undefined;
+                        readonly keyField?: string | undefined;
+                        readonly filterMethod?: import('../tree/interface').FilterFunctionType | undefined;
+                        readonly showUnloadCheckedNodes?: boolean | undefined;
+                        readonly unloadDataList?: import('../tree/interface').AnyPropsArrayType | undefined;
+                        readonly load?: import('../tree/interface').LoadFn | undefined;
+                        readonly filteredNodeCheckable?: boolean | undefined;
+                        readonly cascade?: boolean | undefined;
+                        readonly enableLeafOnly?: boolean | undefined;
+                        readonly disableAll?: boolean | undefined;
+                        readonly defaultExpandAll?: boolean | undefined;
+                        readonly defaultExpandedKeys?: TreeNodeKeyType[] | undefined;
+                        readonly expandedKeys?: TreeNodeKeyType[] | undefined;
+                        readonly draggable?: boolean | undefined;
+                        readonly droppable?: boolean | undefined;
+                        readonly beforeDropMethod?: ((dragKey: TreeNodeKeyType, dropKey: 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/interface').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/interface').TreeProps> & Readonly<{}>, {
+                        setData: (data: import('../tree/interface').AnyPropsArrayType) => void;
+                        setChecked: (key: TreeNodeKeyType, value: boolean) => void;
+                        setCheckedKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+                        checkAll: () => void;
+                        clearChecked: () => void;
+                        setSelected: (key: TreeNodeKeyType, value: boolean) => void;
+                        clearSelected: () => void;
+                        setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+                        setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+                        setExpandAll: (value: boolean) => void;
+                        getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+                        getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
+                        getIndeterminateNodes: () => TreeNode[];
+                        getSelectedNode: () => TreeNode | null;
+                        getSelectedKey: () => TreeNodeKeyType | null;
+                        getExpandNodes: () => TreeNode[];
+                        getExpandKeys: () => TreeNodeKeyType[];
+                        getCurrentVisibleNodes: () => TreeNode[];
+                        getNode: (key: TreeNodeKeyType) => TreeNode | null;
+                        getTreeData: () => TreeNode[];
+                        getFlatData: () => TreeNode[];
+                        getNodesCount: () => number;
+                        insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+                        insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+                        append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+                        prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+                        remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
+                        filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+                        showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+                        loadRootNodes: () => Promise<void>;
+                        updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
+                        updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
+                        scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        data: import('../tree/interface').AnyPropsArrayType;
+                        loading: boolean;
+                        draggable: boolean;
+                        separator: string;
+                        keyField: string;
+                        cascade: boolean;
+                        defaultExpandAll: boolean;
+                        expandedKeys: TreeNodeKeyType[];
+                        defaultExpandedKeys: TreeNodeKeyType[];
+                        checkable: boolean;
+                        emptyText: string;
+                        ignoreMode: import('../tree/interface').IgnoreType;
+                        filteredNodeCheckable: boolean;
+                        expandOnFilter: boolean;
+                        showLeftArrow: boolean;
+                        showRightArrow: boolean;
+                        selectable: boolean;
+                        titleField: string;
+                        showUnloadCheckedNodes: boolean;
+                        unloadDataList: import('../tree/interface').AnyPropsArrayType;
+                        enableLeafOnly: boolean;
+                        disableAll: boolean;
+                        droppable: boolean;
+                        beforeDropMethod: (dragKey: TreeNodeKeyType, dropKey: 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 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/interface').AnyPropsArrayType;
+                    loading: boolean;
+                    draggable: boolean;
+                    separator: string;
+                    keyField: string;
+                    cascade: boolean;
+                    defaultExpandAll: boolean;
+                    expandedKeys: TreeNodeKeyType[];
+                    defaultExpandedKeys: TreeNodeKeyType[];
+                    checkable: boolean;
+                    emptyText: string;
+                    ignoreMode: import('../tree/interface').IgnoreType;
+                    filteredNodeCheckable: boolean;
+                    expandOnFilter: boolean;
+                    showLeftArrow: boolean;
+                    showRightArrow: boolean;
+                    selectable: boolean;
+                    titleField: string;
+                    showUnloadCheckedNodes: boolean;
+                    unloadDataList: import('../tree/interface').AnyPropsArrayType;
+                    enableLeafOnly: boolean;
+                    disableAll: boolean;
+                    droppable: boolean;
+                    beforeDropMethod: (dragKey: TreeNodeKeyType, dropKey: TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
+                    autoLoad: boolean;
+                    unselectOnClick: boolean;
+                    nodeIndent: number;
+                    renderNodeAmount: number;
+                    nodeMinHeight: number;
+                    bufferNodeAmount: number;
+                }> & Omit<Readonly<import('../tree/interface').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/interface').AnyPropsArrayType) => void;
+                    setChecked: (key: TreeNodeKeyType, value: boolean) => void;
+                    setCheckedKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+                    checkAll: () => void;
+                    clearChecked: () => void;
+                    setSelected: (key: TreeNodeKeyType, value: boolean) => void;
+                    clearSelected: () => void;
+                    setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+                    setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+                    setExpandAll: (value: boolean) => void;
+                    getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+                    getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
+                    getIndeterminateNodes: () => TreeNode[];
+                    getSelectedNode: () => TreeNode | null;
+                    getSelectedKey: () => TreeNodeKeyType | null;
+                    getExpandNodes: () => TreeNode[];
+                    getExpandKeys: () => TreeNodeKeyType[];
+                    getCurrentVisibleNodes: () => TreeNode[];
+                    getNode: (key: TreeNodeKeyType) => TreeNode | null;
+                    getTreeData: () => TreeNode[];
+                    getFlatData: () => TreeNode[];
+                    getNodesCount: () => number;
+                    insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+                    insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+                    append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+                    prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+                    remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
+                    filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+                    showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+                    loadRootNodes: () => Promise<void>;
+                    updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
+                    updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
+                    scrollTo: (key: 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;
+            };
+            $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-search').TreeSearchProps> & Readonly<{}>, {
+                clearKeyword: () => void;
+                getKeyword: () => string;
+                search: (keyword1?: string) => Promise<void>;
+                filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+                remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
+                scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
+                insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+                append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+                prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+                clearSelected: () => void;
+                setData: (data: import('../tree/interface').AnyPropsArrayType) => void;
+                setChecked: (key: TreeNodeKeyType, value: boolean) => void;
+                setCheckedKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+                checkAll: () => void;
+                clearChecked: () => void;
+                setSelected: (key: TreeNodeKeyType, value: boolean) => void;
+                setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+                setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+                setExpandAll: (value: boolean) => void;
+                getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+                getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
+                getIndeterminateNodes: () => TreeNode[];
+                getSelectedNode: () => TreeNode | null;
+                getSelectedKey: () => TreeNodeKeyType | null;
+                getExpandNodes: () => TreeNode[];
+                getExpandKeys: () => TreeNodeKeyType[];
+                getCurrentVisibleNodes: () => TreeNode[];
+                getNode: (key: TreeNodeKeyType) => TreeNode | null;
+                getTreeData: () => TreeNode[];
+                getFlatData: () => TreeNode[];
+                getNodesCount: () => number;
+                insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+                showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+                loadRootNodes: () => Promise<void>;
+                updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
+                updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                data: import('../tree/interface').AnyPropsArrayType;
+                loading: boolean;
+                searchPlaceholder: string;
+                checkedButtonText: string;
+                draggable: boolean;
+                separator: string;
+                keyField: string;
+                cascade: boolean;
+                defaultExpandAll: boolean;
+                expandedKeys: TreeNodeKeyType[];
+                defaultExpandedKeys: TreeNodeKeyType[];
+                checkable: boolean;
+                showFooter: boolean;
+                emptyText: string;
+                ignoreMode: import('../tree/interface').IgnoreType;
+                filteredNodeCheckable: boolean;
+                expandOnFilter: boolean;
+                showLeftArrow: boolean;
+                showRightArrow: boolean;
+                selectable: boolean;
+                titleField: string;
+                showUnloadCheckedNodes: boolean;
+                unloadDataList: import('../tree/interface').AnyPropsArrayType;
+                enableLeafOnly: boolean;
+                disableAll: boolean;
+                droppable: boolean;
+                beforeDropMethod: (dragKey: TreeNodeKeyType, dropKey: TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
+                autoLoad: boolean;
+                unselectOnClick: boolean;
+                nodeIndent: number;
+                renderNodeAmount: number;
+                nodeMinHeight: number;
+                bufferNodeAmount: number;
+                showCheckAll: boolean;
+                showCheckedButton: boolean;
+                searchLength: number;
+                searchDisabled: boolean;
+                searchRemote: boolean;
+                searchDebounceTime: 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 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/interface').AnyPropsArrayType;
+            loading: boolean;
+            searchPlaceholder: string;
+            checkedButtonText: string;
+            draggable: boolean;
+            separator: string;
+            keyField: string;
+            cascade: boolean;
+            defaultExpandAll: boolean;
+            expandedKeys: TreeNodeKeyType[];
+            defaultExpandedKeys: TreeNodeKeyType[];
+            checkable: boolean;
+            showFooter: boolean;
+            emptyText: string;
+            ignoreMode: import('../tree/interface').IgnoreType;
+            filteredNodeCheckable: boolean;
+            expandOnFilter: boolean;
+            showLeftArrow: boolean;
+            showRightArrow: boolean;
+            selectable: boolean;
+            titleField: string;
+            showUnloadCheckedNodes: boolean;
+            unloadDataList: import('../tree/interface').AnyPropsArrayType;
+            enableLeafOnly: boolean;
+            disableAll: boolean;
+            droppable: boolean;
+            beforeDropMethod: (dragKey: TreeNodeKeyType, dropKey: TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
+            autoLoad: boolean;
+            unselectOnClick: boolean;
+            nodeIndent: number;
+            renderNodeAmount: number;
+            nodeMinHeight: number;
+            bufferNodeAmount: number;
+            showCheckAll: boolean;
+            showCheckedButton: boolean;
+            searchLength: number;
+            searchDisabled: boolean;
+            searchRemote: boolean;
+            searchDebounceTime: number;
+        }> & 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) => Promise<void>;
+            filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+            remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
+            scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
+            insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+            append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+            prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
+            clearSelected: () => void;
+            setData: (data: import('../tree/interface').AnyPropsArrayType) => void;
+            setChecked: (key: TreeNodeKeyType, value: boolean) => void;
+            setCheckedKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+            checkAll: () => void;
+            clearChecked: () => void;
+            setSelected: (key: TreeNodeKeyType, value: boolean) => void;
+            setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+            setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
+            setExpandAll: (value: boolean) => void;
+            getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+            getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
+            getIndeterminateNodes: () => TreeNode[];
+            getSelectedNode: () => TreeNode | null;
+            getSelectedKey: () => TreeNodeKeyType | null;
+            getExpandNodes: () => TreeNode[];
+            getExpandKeys: () => TreeNodeKeyType[];
+            getCurrentVisibleNodes: () => TreeNode[];
+            getNode: (key: TreeNodeKeyType) => TreeNode | null;
+            getTreeData: () => TreeNode[];
+            getFlatData: () => TreeNode[];
+            getNodesCount: () => number;
+            insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
+            showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+            loadRootNodes: () => Promise<void>;
+            updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
+            updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Partial<Record<string, (_: any) => any>> & {
+                'search-input'?(_: {}): any;
+                actions?(_: {}): any;
+                footer?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TreeDropProps, {
+    filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+    search: (keyword1?: string) => Promise<void>;
     remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
-    scrollTo: (key: TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+    scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
     insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
     append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
     prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
@@ -20,8 +587,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
     setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
     setExpandAll: (value: boolean) => void;
-    getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-    getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNodeKeyType[];
+    getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+    getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
     getIndeterminateNodes: () => TreeNode[];
     getSelectedNode: () => TreeNode | null;
     getSelectedKey: () => TreeNodeKeyType | null;
@@ -33,7 +600,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     getFlatData: () => TreeNode[];
     getNodesCount: () => number;
     insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
-    showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+    showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
     loadRootNodes: () => Promise<void>;
     updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
     updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
@@ -44,7 +611,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     loading: boolean;
     searchPlaceholder: string;
     checkedButtonText: string;
-    placement: "bottom" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end";
+    placement: import('./interface').PlacementType;
     draggable: boolean;
     clearable: boolean;
     separator: string;
@@ -57,7 +624,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     showFooter: boolean;
     emptyText: string;
     transfer: boolean;
-    ignoreMode: "none" | "children" | "parents";
+    ignoreMode: import('../tree/interface').IgnoreType;
     filteredNodeCheckable: boolean;
     expandOnFilter: boolean;
     showLeftArrow: boolean;
@@ -100,7 +667,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/interface').IgnoreType | undefined;
             readonly titleField?: string | undefined;
             readonly keyField?: string | undefined;
             readonly filterMethod?: import('../tree/interface').FilterFunctionType | undefined;
@@ -118,14 +685,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             readonly droppable?: boolean | undefined;
             readonly beforeDropMethod?: ((dragKey: TreeNodeKeyType, dropKey: 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/interface').ShowLine | undefined;
+            readonly nodeClassName?: (string | object | Array<string | object> | ((node: TreeNode) => string | object | Array<string | object>)) | undefined;
+            readonly showLine?: (boolean | import('../tree/interface').ShowLine) | undefined;
             readonly animation?: boolean | undefined;
             readonly nodeIndent?: number | undefined;
             readonly renderNodeAmount?: number | undefined;
@@ -160,7 +725,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/interface').IgnoreType | undefined;
                     readonly titleField?: string | undefined;
                     readonly keyField?: string | undefined;
                     readonly filterMethod?: import('../tree/interface').FilterFunctionType | undefined;
@@ -178,14 +743,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                     readonly droppable?: boolean | undefined;
                     readonly beforeDropMethod?: ((dragKey: TreeNodeKeyType, dropKey: 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/interface').ShowLine | undefined;
+                    readonly nodeClassName?: (string | object | Array<string | object> | ((node: TreeNode) => string | object | Array<string | object>)) | undefined;
+                    readonly showLine?: (boolean | import('../tree/interface').ShowLine) | undefined;
                     readonly animation?: boolean | undefined;
                     readonly nodeIndent?: number | undefined;
                     readonly renderNodeAmount?: number | undefined;
@@ -203,8 +766,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;
@@ -219,8 +782,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                     setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
                     setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
                     setExpandAll: (value: boolean) => void;
-                    getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-                    getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNodeKeyType[];
+                    getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+                    getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
                     getIndeterminateNodes: () => TreeNode[];
                     getSelectedNode: () => TreeNode | null;
                     getSelectedKey: () => TreeNodeKeyType | null;
@@ -236,12 +799,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                     append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
                     prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
                     remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
-                    filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType | undefined) => void;
-                    showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+                    filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+                    showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
                     loadRootNodes: () => Promise<void>;
                     updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
                     updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
-                    scrollTo: (key: TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+                    scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
                 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
                     data: import('../tree/interface').AnyPropsArrayType;
                     loading: boolean;
@@ -254,7 +817,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                     defaultExpandedKeys: TreeNodeKeyType[];
                     checkable: boolean;
                     emptyText: string;
-                    ignoreMode: "none" | "children" | "parents";
+                    ignoreMode: import('../tree/interface').IgnoreType;
                     filteredNodeCheckable: boolean;
                     expandOnFilter: boolean;
                     showLeftArrow: boolean;
@@ -274,25 +837,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 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/interface').AnyPropsArrayType;
                 loading: boolean;
@@ -305,7 +868,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                 defaultExpandedKeys: TreeNodeKeyType[];
                 checkable: boolean;
                 emptyText: string;
-                ignoreMode: "none" | "children" | "parents";
+                ignoreMode: import('../tree/interface').IgnoreType;
                 filteredNodeCheckable: boolean;
                 expandOnFilter: boolean;
                 showLeftArrow: boolean;
@@ -335,8 +898,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                 setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
                 setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
                 setExpandAll: (value: boolean) => void;
-                getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-                getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNodeKeyType[];
+                getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+                getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
                 getIndeterminateNodes: () => TreeNode[];
                 getSelectedNode: () => TreeNode | null;
                 getSelectedKey: () => TreeNodeKeyType | null;
@@ -352,12 +915,12 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
                 append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
                 prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
                 remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
-                filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType | undefined) => void;
-                showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+                filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
+                showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
                 loadRootNodes: () => Promise<void>;
                 updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
                 updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
-                scrollTo: (key: TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+                scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
             }> & {} & import('vue').ComponentCustomProperties & {} & {
                 $slots: {
                     node?(_: {
@@ -377,18 +940,18 @@ 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;
         $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('../tree/interface').FilterFunctionType | undefined) => void;
+            search: (keyword1?: string) => Promise<void>;
+            filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
             remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
-            scrollTo: (key: TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+            scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
             insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
             append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
             prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
@@ -402,8 +965,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
             setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
             setExpandAll: (value: boolean) => void;
-            getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-            getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNodeKeyType[];
+            getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+            getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
             getIndeterminateNodes: () => TreeNode[];
             getSelectedNode: () => TreeNode | null;
             getSelectedKey: () => TreeNodeKeyType | null;
@@ -415,7 +978,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             getFlatData: () => TreeNode[];
             getNodesCount: () => number;
             insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
-            showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+            showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
             loadRootNodes: () => Promise<void>;
             updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
             updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
@@ -434,7 +997,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             checkable: boolean;
             showFooter: boolean;
             emptyText: string;
-            ignoreMode: "none" | "children" | "parents";
+            ignoreMode: import('../tree/interface').IgnoreType;
             filteredNodeCheckable: boolean;
             expandOnFilter: boolean;
             showLeftArrow: boolean;
@@ -460,25 +1023,25 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             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 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/interface').AnyPropsArrayType;
         loading: boolean;
@@ -494,7 +1057,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         checkable: boolean;
         showFooter: boolean;
         emptyText: string;
-        ignoreMode: "none" | "children" | "parents";
+        ignoreMode: import('../tree/interface').IgnoreType;
         filteredNodeCheckable: boolean;
         expandOnFilter: boolean;
         showLeftArrow: boolean;
@@ -522,10 +1085,10 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     }> & 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('../tree/interface').FilterFunctionType | undefined) => void;
+        search: (keyword1?: string) => Promise<void>;
+        filter: (keyword: string, filterMethod?: import('../tree/interface').FilterFunctionType) => void;
         remove: (removedKey: TreeNodeKeyType) => TreeNode | null;
-        scrollTo: (key: TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+        scrollTo: (key: TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
         insertBefore: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
         append: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
         prepend: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, parentKey: TreeNodeKeyType) => TreeNode | null;
@@ -539,8 +1102,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         setExpand: (key: TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
         setExpandKeys: (keys: TreeNodeKeyType[], value: boolean) => void;
         setExpandAll: (value: boolean) => void;
-        getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
-        getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNodeKeyType[];
+        getCheckedNodes: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNode[];
+        getCheckedKeys: (ignoreMode?: import('../tree/interface').IgnoreType) => TreeNodeKeyType[];
         getIndeterminateNodes: () => TreeNode[];
         getSelectedNode: () => TreeNode | null;
         getSelectedKey: () => TreeNodeKeyType | null;
@@ -552,7 +1115,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
         getFlatData: () => TreeNode[];
         getNodesCount: () => number;
         insertAfter: (insertedNode: TreeNodeKeyType | import('../tree/interface').ITreeNodeOptions, referenceKey: TreeNodeKeyType) => TreeNode | null;
-        showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+        showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
         loadRootNodes: () => Promise<void>;
         updateNode: (key: TreeNodeKeyType, newNode: import('../tree/interface').ITreeNodeOptions) => void;
         updateNodes: (newNodes: import('../tree/interface').ITreeNodeOptions[]) => void;
@@ -563,93 +1126,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
             footer?(_: {}): any;
         };
     }) | null;
-}, any>, Partial<Record<string, (_: any) => any>> & {
-    default?(_: {
-        checkedNodes: {
-            [x: string]: any;
-            _level: number;
-            checked: boolean;
-            selected: boolean;
-            indeterminate: boolean;
-            disabled: boolean;
-            expand: boolean;
-            visible: boolean;
-            _filterVisible: boolean;
-            _parent: any | null;
-            children: any[];
-            isLeaf: boolean;
-            _loading: boolean;
-            _loaded: boolean;
-            readonly _keyField: string;
-            readonly _remote: boolean;
-            setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
-        }[];
-        checkedKeys: TreeNodeKeyType[];
-        selectedNode?: {
-            [x: string]: any;
-            _level: number;
-            checked: boolean;
-            selected: boolean;
-            indeterminate: boolean;
-            disabled: boolean;
-            expand: boolean;
-            visible: boolean;
-            _filterVisible: boolean;
-            _parent: any | null;
-            children: any[];
-            isLeaf: boolean;
-            _loading: boolean;
-            _loaded: boolean;
-            readonly _keyField: string;
-            readonly _remote: boolean;
-            setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
-        } | undefined;
-        selectedKey?: TreeNodeKeyType | undefined;
-    }): any;
-    display?(_: {
-        checkedNodes: {
-            [x: string]: any;
-            _level: number;
-            checked: boolean;
-            selected: boolean;
-            indeterminate: boolean;
-            disabled: boolean;
-            expand: boolean;
-            visible: boolean;
-            _filterVisible: boolean;
-            _parent: any | null;
-            children: any[];
-            isLeaf: boolean;
-            _loading: boolean;
-            _loaded: boolean;
-            readonly _keyField: string;
-            readonly _remote: boolean;
-            setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
-        }[];
-        checkedKeys: TreeNodeKeyType[];
-        selectedNode?: {
-            [x: string]: any;
-            _level: number;
-            checked: boolean;
-            selected: boolean;
-            indeterminate: boolean;
-            disabled: boolean;
-            expand: boolean;
-            visible: boolean;
-            _filterVisible: boolean;
-            _parent: any | null;
-            children: any[];
-            isLeaf: boolean;
-            _loading: boolean;
-            _loaded: boolean;
-            readonly _keyField: string;
-            readonly _remote: boolean;
-            setChildren: (children: import('../tree/interface').ITreeNodeOptions[]) => void;
-        } | undefined;
-        selectedKey?: TreeNodeKeyType | undefined;
-    }): any;
-    clear?(_: {}): any;
-}>;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {