树形控件 AsamTree

使用场景

展示层级节点，并让用户展开、选择或勾选本地数据。

基础用法与状态

下列示例只使用本入口的实际公开能力。

基础用法与状态

vue

<template>
	<AsamTree
		v-bind="{ data, nodeKey: 'id', showCheckbox: true, defaultExpandedKeys: ['root'] }"
		@node-click="selected = $event.label"
	>
		<template #default="{ data: item }">
			<span>{{ item.label }}</span>
		</template>
	</AsamTree>
	<p class="example-paragraph" role="status">当前节点：{{ selected }}</p>
</template>

<script lang="ts" setup>
defineOptions({ name: 'AsamTreeBasicDemo' });
import { ref } from 'vue';
import { AsamTree } from '@asam-ui/ui';
const data = [
	{
		id: 'root',
		label: '本地记录',
		children: [
			{ id: 'draft', label: '草稿' },
			{ id: 'locked', label: '锁定记录', disabled: true }
		]
	}
];
const selected = ref('');
</script>

<style scoped>
p:where(.example-paragraph) {
	margin-block: 16px;
	line-height: 1.8;
	overflow-wrap: anywhere;
}
</style>

vue

<template>
	<AsamTree
		v-bind="{ data, nodeKey: 'id', showCheckbox: true, defaultExpandedKeys: ['root'] }"
		@node-click="selected = $event.label"
	>
		<template #default="{ data: item }">
			<span>{{ item.label }}</span>
		</template>
	</AsamTree>
	<p class="example-paragraph" role="status">当前节点：{{ selected }}</p>
</template>

<script setup>
defineOptions({ name: 'AsamTreeBasicDemo' });
import { ref } from 'vue';
import { AsamTree } from '@asam-ui/ui';
const data = [
	{
		id: 'root',
		label: '本地记录',
		children: [
			{ id: 'draft', label: '草稿' },
			{ id: 'locked', label: '锁定记录', disabled: true }
		]
	}
];
const selected = ref('');
</script>

<style scoped>
p:where(.example-paragraph) {
	margin-block: 16px;
	line-height: 1.8;
	overflow-wrap: anywhere;
}
</style>

使用约定

data 与 props 映射实际 label/children/disabled 等字段；使用勾选和实例节点操作时提供稳定的 nodeKey。完整说明。

原生协议完整用法与 API

以下用法对应固定 2.14.7。Cascader 与 TreeSelect 的示例显式使用 value-mode="native"；其原生值、路径、字段映射和回调不能直接套到标准化模式。API 表保留原生默认值，ASAM 覆盖值与四档尺寸以下列约定为准。

用清晰的层级结构展示信息，可展开或折叠。

基础用法

基础的树形结构展示

基础用法

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:data="data"
		:props="defaultProps"
		@node-click="handleNodeClick"
	/>
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/basic.vue

interface Tree {
	label: string;
	children?: Tree[];
}

const handleNodeClick = (data: Tree) => {
	console.log(data);
};

const data: Tree[] = [
	{
		label: '一级节点 1',
		children: [
			{
				label: '二级节点 1-1',
				children: [
					{
						label: '三级节点 1-1-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 2',
		children: [
			{
				label: '二级节点 2-1',
				children: [
					{
						label: '三级节点 2-1-1'
					}
				]
			},
			{
				label: '二级节点 2-2',
				children: [
					{
						label: '三级节点 2-2-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 3',
		children: [
			{
				label: '二级节点 3-1',
				children: [
					{
						label: '三级节点 3-1-1'
					}
				]
			},
			{
				label: '二级节点 3-2',
				children: [
					{
						label: '三级节点 3-2-1'
					}
				]
			}
		]
	}
];

const defaultProps = {
	children: 'children',
	label: 'label'
};
</script>

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:data="data"
		:props="defaultProps"
		@node-click="handleNodeClick"
	/>
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
const handleNodeClick = (data) => {
	console.log(data);
};
const data = [
	{
		label: '一级节点 1',
		children: [
			{
				label: '二级节点 1-1',
				children: [
					{
						label: '三级节点 1-1-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 2',
		children: [
			{
				label: '二级节点 2-1',
				children: [
					{
						label: '三级节点 2-1-1'
					}
				]
			},
			{
				label: '二级节点 2-2',
				children: [
					{
						label: '三级节点 2-2-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 3',
		children: [
			{
				label: '二级节点 3-1',
				children: [
					{
						label: '三级节点 3-1-1'
					}
				]
			},
			{
				label: '二级节点 3-2',
				children: [
					{
						label: '三级节点 3-2-1'
					}
				]
			}
		]
	}
];
const defaultProps = {
	children: 'children',
	label: 'label'
};
</script>

可选择的虚拟树

适用于需要选择层级时使用。

本例还展示了动态加载节点数据的方法。

可选择的虚拟树

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:props="props"
		:load="loadNode"
		lazy
		show-checkbox
		@check-change="handleCheckChange"
	/>
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/selectable.vue

import type { AsamTreeLoadFunction } from '@asam-ui/ui';

interface Tree {
	name: string;
}

let count = 1;
const props = {
	label: 'name',
	children: 'zones'
};

const handleCheckChange = (data: Tree, checked: boolean, indeterminate: boolean) => {
	console.log(data, checked, indeterminate);
};

const loadNode: AsamTreeLoadFunction = (node, resolve) => {
	if (node.level === 0) {
		return resolve([{ name: 'region1' }, { name: 'region2' }]);
	}
	if (node.level > 3) return resolve([]);

	let hasChild = false;
	if (node.data.name === 'region1') {
		hasChild = true;
	} else if (node.data.name === 'region2') {
		hasChild = false;
	} else {
		hasChild = Math.random() > 0.5;
	}

	setTimeout(() => {
		let data: Tree[];
		if (hasChild) {
			data = [
				{
					name: `zone${count++}`
				},
				{
					name: `zone${count++}`
				}
			];
		} else {
			data = [];
		}

		resolve(data);
	}, 500);
};
</script>

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:props="props"
		:load="loadNode"
		lazy
		show-checkbox
		@check-change="handleCheckChange"
	/>
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
let count = 1;
const props = {
	label: 'name',
	children: 'zones'
};
const handleCheckChange = (data, checked, indeterminate) => {
	console.log(data, checked, indeterminate);
};
const loadNode = (node, resolve) => {
	if (node.level === 0) {
		return resolve([{ name: 'region1' }, { name: 'region2' }]);
	}
	if (node.level > 3) return resolve([]);
	let hasChild = false;
	if (node.data.name === 'region1') {
		hasChild = true;
	} else if (node.data.name === 'region2') {
		hasChild = false;
	} else {
		hasChild = Math.random() > 0.5;
	}
	setTimeout(() => {
		let data;
		if (hasChild) {
			data = [
				{
					name: `zone${count++}`
				},
				{
					name: `zone${count++}`
				}
			];
		} else {
			data = [];
		}
		resolve(data);
	}, 500);
};
</script>

使用提示

使用 show-checkbox 时，check-on-click-leaf 默认为 true，点击叶子节点本身即可切换其选中状态。

懒加载自定义叶子节点

由于在点击节点时才进行该层数据的获取，默认情况下 Tree 无法预知某个节点是否为叶子节点，所以会为每个节点添加一个下拉按钮，如果节点没有下层数据，则点击后下拉按钮会消失。同时，你也可以提前告知 Tree 某个节点是否为叶子节点，从而避免在叶子节点前渲染下拉按钮。

懒加载自定义叶子节点

许可

vue

<template>
	<AsamTree style="max-width: 600px" :props="props" :load="loadNode" lazy show-checkbox />
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/custom-leaf.vue

import type { AsamTreeLoadFunction } from '@asam-ui/ui';

interface Tree {
	name: string;
	leaf?: boolean;
}

const props = {
	label: 'name',
	children: 'zones',
	isLeaf: 'leaf'
};

const loadNode: AsamTreeLoadFunction = (node, resolve) => {
	if (node.level === 0) {
		return resolve([{ name: 'region' }]);
	}
	if (node.level > 1) return resolve([]);

	setTimeout(() => {
		const data: Tree[] = [
			{
				name: 'leaf',
				leaf: true
			},
			{
				name: 'zone'
			}
		];

		resolve(data);
	}, 500);
};
</script>

许可

vue

<template>
	<AsamTree style="max-width: 600px" :props="props" :load="loadNode" lazy show-checkbox />
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
const props = {
	label: 'name',
	children: 'zones',
	isLeaf: 'leaf'
};
const loadNode = (node, resolve) => {
	if (node.level === 0) {
		return resolve([{ name: 'region' }]);
	}
	if (node.level > 1) return resolve([]);
	setTimeout(() => {
		const data = [
			{
				name: 'leaf',
				leaf: true
			},
			{
				name: 'zone'
			}
		];
		resolve(data);
	}, 500);
};
</script>

多次懒加载

加载远程节点数据时，懒加载有时可能失败。在这种情况下，您可以调用 reject 以保持节点状态，并允许远程加载继续。

多次懒加载

许可

vue

<template>
	<AsamTree style="max-width: 600px" :props="props" :load="loadNode" lazy />
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/multiple-times-load.vue

import type { AsamTreeLoadFunction } from '@asam-ui/ui';

const props = {
	label: 'name',
	children: 'zones',
	isLeaf: 'leaf'
};

let time = 0;
const loadNode: AsamTreeLoadFunction = (node, resolve, reject) => {
	if (node.level === 0) {
		return resolve([{ name: 'region' }]);
	}
	time++;
	if (node.level >= 1) {
		setTimeout(() => {
			if (time > 3) {
				return resolve([
					{ name: 'zone1', leaf: true },
					{ name: 'zone2', leaf: true },
					{ name: 'zone3', leaf: true }
				]);
			} else {
				return reject();
			}
		}, 3000);
	}
};
</script>

许可

vue

<template>
	<AsamTree style="max-width: 600px" :props="props" :load="loadNode" lazy />
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
const props = {
	label: 'name',
	children: 'zones',
	isLeaf: 'leaf'
};
let time = 0;
const loadNode = (node, resolve, reject) => {
	if (node.level === 0) {
		return resolve([{ name: 'region' }]);
	}
	time++;
	if (node.level >= 1) {
		setTimeout(() => {
			if (time > 3) {
				return resolve([
					{ name: 'zone1', leaf: true },
					{ name: 'zone2', leaf: true },
					{ name: 'zone3', leaf: true }
				]);
			} else {
				return reject();
			}
		}, 3000);
	}
};
</script>

禁用复选框

节点的复选框可以设置为禁用。

在示例中，属性在 defaultProps 中声明了 disabled，一些节点被设置为 disabled：true。相应的复选框已禁用，不能点击。

禁用复选框

许可

vue

<template>
	<AsamTree style="max-width: 600px" :data="data" :props="defaultProps" show-checkbox />
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/disabled.vue

const defaultProps = {
	children: 'children',
	label: 'label',
	disabled: 'disabled'
};

const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 3,
				label: '二级节点 2-1',
				children: [
					{
						id: 4,
						label: '三级节点 3-1-1'
					},
					{
						id: 5,
						label: '三级节点 3-1-2',
						disabled: true
					}
				]
			},
			{
				id: 2,
				label: '二级节点 2-2',
				disabled: true,
				children: [
					{
						id: 6,
						label: '三级节点 3-2-1'
					},
					{
						id: 7,
						label: '三级节点 3-2-2',
						disabled: true
					}
				]
			}
		]
	}
];
</script>

许可

vue

<template>
	<AsamTree style="max-width: 600px" :data="data" :props="defaultProps" show-checkbox />
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/disabled.vue
const defaultProps = {
	children: 'children',
	label: 'label',
	disabled: 'disabled'
};
const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 3,
				label: '二级节点 2-1',
				children: [
					{
						id: 4,
						label: '三级节点 3-1-1'
					},
					{
						id: 5,
						label: '三级节点 3-1-2',
						disabled: true
					}
				]
			},
			{
				id: 2,
				label: '二级节点 2-2',
				disabled: true,
				children: [
					{
						id: 6,
						label: '三级节点 3-2-1'
					},
					{
						id: 7,
						label: '三级节点 3-2-2',
						disabled: true
					}
				]
			}
		]
	}
];
</script>

默认扩展和默认检查

树节点可以在初始化阶段被设置为展开或选中。

分别通过 default-expanded-keys 和 default-checked-keys 设置默认展开和默认选中的节点。需要注意的是，此时必须设置 node-key，其值为节点数据中的一个字段名，该字段在整棵树中是唯一的。

默认扩展和默认检查

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:data="data"
		show-checkbox
		node-key="id"
		:default-expanded-keys="[2, 3]"
		:default-checked-keys="[5]"
		:props="defaultProps"
	/>
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/default-state.vue

const defaultProps = {
	children: 'children',
	label: 'label'
};
const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:data="data"
		show-checkbox
		node-key="id"
		:default-expanded-keys="[2, 3]"
		:default-checked-keys="[5]"
		:props="defaultProps"
	/>
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/default-state.vue
const defaultProps = {
	children: 'children',
	label: 'label'
};
const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

树节点的选择

本例展示如何获取和设置选中节点。获取和设置各有两种方式：通过 node 或通过 key。如果需要通过 key 来获取或设置，则必须设置 node-key。

树节点的选择

许可

vue

<template>
	<div class="demo-root-layout">
		<AsamTree
			ref="treeRef"
			style="max-width: 600px"
			:data="data"
			show-checkbox
			default-expand-all
			node-key="id"
			highlight-current
			:props="defaultProps"
		/>

		<div class="flex flex-wrap demo-gap mt-2">
			<AsamButton type="default" class="!ml-0" @click="getCheckedNodes"
				>按节点获取</AsamButton
			>
			<AsamButton type="default" class="!ml-0" @click="getCheckedKeys">按键获取</AsamButton>
			<AsamButton type="default" class="!ml-0" @click="setCheckedNodes"
				>按节点设置</AsamButton
			>
			<AsamButton type="default" class="!ml-0" @click="setCheckedKeys">按键设置</AsamButton>
			<AsamButton type="default" class="!ml-0" @click="resetChecked">重置</AsamButton>
		</div>
	</div>
</template>

<script lang="ts" setup>


import { AsamTree, AsamButton } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/checking-tree.vue

import { ref } from 'vue';

import type { AsamTreeRenderContentContext, AsamTreeInstance } from '@asam-ui/ui';

interface Tree {
	id: number;
	label: string;
	children?: Tree[];
}
type Node = AsamTreeRenderContentContext['node'];

const treeRef = ref<AsamTreeInstance>();

const getCheckedNodes = () => {
	console.log(treeRef.value!.getCheckedNodes(false, false));
};
const getCheckedKeys = () => {
	console.log(treeRef.value!.getCheckedKeys(false));
};
const setCheckedNodes = () => {
	treeRef.value!.setCheckedNodes(
		[
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 9,
				label: '三级节点 1-1-1'
			}
		] as Node[],
		false
	);
};
const setCheckedKeys = () => {
	treeRef.value!.setCheckedKeys([3], false);
};
const resetChecked = () => {
	treeRef.value!.setCheckedKeys([], false);
};

const defaultProps = {
	children: 'children',
	label: 'label'
};

const data: Tree[] = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

<style scoped>
/* Keep layout utilities local so the downloaded SFC needs no CSS preset. */
.flex {
	display: flex;
}
.flex-wrap {
	flex-wrap: wrap;
}
.demo-gap {
	gap: var(--asam-space-sm);
}
.mt-2 {
	margin-top: var(--asam-space-sm);
}
</style>

<style scoped>
.demo-root-layout {
	display: grid;
	gap: var(--asam-space-md);
	justify-items: start;
}
.demo-root-layout > :is(p, pre, output) {
	margin-block: 0;
}
</style>

许可

vue

<template>
	<div class="demo-root-layout">
		<AsamTree
			ref="treeRef"
			style="max-width: 600px"
			:data="data"
			show-checkbox
			default-expand-all
			node-key="id"
			highlight-current
			:props="defaultProps"
		/>

		<div class="flex flex-wrap demo-gap mt-2">
			<AsamButton type="default" class="!ml-0" @click="getCheckedNodes"
				>按节点获取</AsamButton
			>
			<AsamButton type="default" class="!ml-0" @click="getCheckedKeys">按键获取</AsamButton>
			<AsamButton type="default" class="!ml-0" @click="setCheckedNodes"
				>按节点设置</AsamButton
			>
			<AsamButton type="default" class="!ml-0" @click="setCheckedKeys">按键设置</AsamButton>
			<AsamButton type="default" class="!ml-0" @click="resetChecked">重置</AsamButton>
		</div>
	</div>
</template>

<script setup>


import { AsamTree, AsamButton } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/checking-tree.vue
import { ref } from 'vue';
const treeRef = ref();
const getCheckedNodes = () => {
	console.log(treeRef.value.getCheckedNodes(false, false));
};
const getCheckedKeys = () => {
	console.log(treeRef.value.getCheckedKeys(false));
};
const setCheckedNodes = () => {
	treeRef.value.setCheckedNodes(
		[
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 9,
				label: '三级节点 1-1-1'
			}
		],
		false
	);
};
const setCheckedKeys = () => {
	treeRef.value.setCheckedKeys([3], false);
};
const resetChecked = () => {
	treeRef.value.setCheckedKeys([], false);
};
const defaultProps = {
	children: 'children',
	label: 'label'
};
const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

<style scoped>
/* Keep layout utilities local so the downloaded SFC needs no CSS preset. */
.flex {
	display: flex;
}
.flex-wrap {
	flex-wrap: wrap;
}
.demo-gap {
	gap: var(--asam-space-sm);
}
.mt-2 {
	margin-top: var(--asam-space-sm);
}
</style>

<style scoped>
.demo-root-layout {
	display: grid;
	gap: var(--asam-space-md);
	justify-items: start;
}
.demo-root-layout > :is(p, pre, output) {
	margin-block: 0;
}
</style>

自定义节点内容

节点的内容支持自定义，可以在节点区添加按钮或图标等内容

树节点内容支持 render-content 渲染函数和作用域插槽两种自定义方式。完整说明。

自定义节点内容

许可

vue

<template>
	<div class="custom-tree-container">
		<p class="example-paragraph">使用 render-content</p>
		<AsamTree
			ref="treeRef1"
			style="max-width: 600px"
			:data="dataSource"
			show-checkbox
			node-key="id"
			default-expand-all
			:expand-on-click-node="false"
			:render-content="renderContent"
		/>
		<p class="example-paragraph">使用作用域插槽</p>
		<AsamTree
			ref="treeRef2"
			style="max-width: 600px"
			:data="dataSource"
			show-checkbox
			node-key="id"
			default-expand-all
			:expand-on-click-node="false"
		>
			<template #default="{ node, data }">
				<div class="custom-tree-node">
					<span>{{ node.label }}</span>
					<div>
						<AsamButton type="default" link @click="append(data)"> 追加 </AsamButton>
						<AsamButton
							style="margin-left: 4px"
							type="default"
							link
							@click="remove(node, data)"
						>
							删除
						</AsamButton>
					</div>
				</div>
			</template>
		</AsamTree>
	</div>
</template>

<script lang="ts" setup>


import { AsamTree, AsamButton } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/customized-node.vue

import { ref } from 'vue';

import type {
	AsamTreeRenderContentContext,
	AsamTreeRenderContentFunction,
	AsamTreeInstance
} from '@asam-ui/ui';

interface Tree {
	id: number;
	label: string;
	children?: Tree[];
}
type Node = AsamTreeRenderContentContext['node'];
type Data = AsamTreeRenderContentContext['data'];

let id = 1000;
const treeRef1 = ref<AsamTreeInstance>();
const treeRef2 = ref<AsamTreeInstance>();

const append = (data: Data) => {
	const newChild = { id: id++, label: 'testtest', children: [] };
	treeRef1.value?.append(newChild, data);
	treeRef2.value?.append(newChild, data);
};

const remove = (node: Node, data: Data) => {
	treeRef1.value?.remove(data);
	treeRef2.value?.remove(data);
};

const renderContent: AsamTreeRenderContentFunction = (h, { node, data }) => {
	return h(
		'div',
		{
			class: 'custom-tree-node'
		},
		[
			h('span', null, node.label),
			h('div', null, [
				h(
					AsamButton,
					{
						type: 'default',
						link: true,
						onClick: () => append(data)
					},
					{
						default: () => '添加'
					}
				),
				h(
					AsamButton,
					{
						type: 'danger',
						link: true,
						style: 'margin-left: 4px',
						onClick: () => remove(node, data)
					},
					{
						default: () => '删除'
					}
				)
			])
		]
	);
};

const dataSource = ref<Tree[]>([
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
]);
</script>

<style>
.custom-tree-node {
	flex: 1;
	display: flex;
	align-items: center;
	justify-content: space-between;
	font-size: 14px;
	padding-right: 8px;
}
</style>

<style scoped>
p:where(.example-paragraph) {
	margin-block: 16px;
	line-height: 1.8;
	overflow-wrap: anywhere;
}
</style>

许可

vue

<template>
	<div class="custom-tree-container">
		<p class="example-paragraph">使用 render-content</p>
		<AsamTree
			ref="treeRef1"
			style="max-width: 600px"
			:data="dataSource"
			show-checkbox
			node-key="id"
			default-expand-all
			:expand-on-click-node="false"
			:render-content="renderContent"
		/>
		<p class="example-paragraph">使用作用域插槽</p>
		<AsamTree
			ref="treeRef2"
			style="max-width: 600px"
			:data="dataSource"
			show-checkbox
			node-key="id"
			default-expand-all
			:expand-on-click-node="false"
		>
			<template #default="{ node, data }">
				<div class="custom-tree-node">
					<span>{{ node.label }}</span>
					<div>
						<AsamButton type="default" link @click="append(data)"> 追加 </AsamButton>
						<AsamButton
							style="margin-left: 4px"
							type="default"
							link
							@click="remove(node, data)"
						>
							删除
						</AsamButton>
					</div>
				</div>
			</template>
		</AsamTree>
	</div>
</template>

<script setup>


import { AsamTree, AsamButton } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/customized-node.vue
import { ref } from 'vue';
let id = 1000;
const treeRef1 = ref();
const treeRef2 = ref();
const append = (data) => {
	const newChild = { id: id++, label: 'testtest', children: [] };
	treeRef1.value?.append(newChild, data);
	treeRef2.value?.append(newChild, data);
};
const remove = (node, data) => {
	treeRef1.value?.remove(data);
	treeRef2.value?.remove(data);
};
const renderContent = (h, { node, data }) => {
	return h(
		'div',
		{
			class: 'custom-tree-node'
		},
		[
			h('span', null, node.label),
			h('div', null, [
				h(
					AsamButton,
					{
						type: 'default',
						link: true,
						onClick: () => append(data)
					},
					{
						default: () => '添加'
					}
				),
				h(
					AsamButton,
					{
						type: 'danger',
						link: true,
						style: 'margin-left: 4px',
						onClick: () => remove(node, data)
					},
					{
						default: () => '删除'
					}
				)
			])
		]
	);
};
const dataSource = ref([
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
]);
</script>

<style>
.custom-tree-node {
	flex: 1;
	display: flex;
	align-items: center;
	justify-content: space-between;
	font-size: 14px;
	padding-right: 8px;
}
</style>

<style scoped>
p:where(.example-paragraph) {
	margin-block: 16px;
	line-height: 1.8;
	overflow-wrap: anywhere;
}
</style>

自定义节点类名

节点的类名支持自定义。

使用 props.class 来建立节点的类名。

自定义节点类名

许可

vue

<template>
	<div class="custom-tree-node-container">
		<AsamTree
			style="max-width: 600px"
			:data="data"
			show-checkbox
			node-key="id"
			default-expand-all
			:expand-on-click-node="false"
			:props="{ class: customNodeClass }"
		/>
	</div>
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/custom-node-class.vue

import type { AsamTreeNodeData } from '@asam-ui/ui';

interface Tree {
	id: number;
	label: string;
	isPenultimate?: boolean;
	children?: Tree[];
}

const customNodeClass = ({ isPenultimate }: AsamTreeNodeData) =>
	isPenultimate ? 'is-penultimate' : '';

const data: Tree[] = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				isPenultimate: true,
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		isPenultimate: true,
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		isPenultimate: true,
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

<style>
.is-penultimate > .el-tree-node__content .el-tree-node__label {
	color: #626aef;
}

.is-penultimate > .el-tree-node__children > div {
	display: inline-block;
	margin-right: 4px;

	.el-tree-node__content {
		padding-right: 16px;
	}

	&:not(:first-child) .el-tree-node__content {
		padding-left: 0 !important;
	}
}
</style>

许可

vue

<template>
	<div class="custom-tree-node-container">
		<AsamTree
			style="max-width: 600px"
			:data="data"
			show-checkbox
			node-key="id"
			default-expand-all
			:expand-on-click-node="false"
			:props="{ class: customNodeClass }"
		/>
	</div>
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
const customNodeClass = ({ isPenultimate }) => (isPenultimate ? 'is-penultimate' : '');
const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				isPenultimate: true,
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		isPenultimate: true,
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		isPenultimate: true,
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

<style>
.is-penultimate > .el-tree-node__content .el-tree-node__label {
	color: #626aef;
}

.is-penultimate > .el-tree-node__children > div {
	display: inline-block;
	margin-right: 4px;

	.el-tree-node__content {
		padding-right: 16px;
	}

	&:not(:first-child) .el-tree-node__content {
		padding-left: 0 !important;
	}
}
</style>

树节点过滤

树节点是可以被过滤的

调用 Tree 实例对象的 filter 方法来过滤树节点。方法的参数就是过滤关键字。需要注意的是，此时需要设置 filter-node-method 属性，其值为过滤函数。

树节点过滤

许可

vue

<template>
	<div class="demo-root-layout">
		<AsamInput
			:model-value="filterText"
			class="w-60 mb-2"
			placeholder="筛选关键字"
			@update:model-value="updateFilterText"
		/>

		<AsamTree
			ref="treeRef"
			style="max-width: 600px"
			class="filter-tree"
			:data="data"
			:props="defaultProps"
			default-expand-all
			:filter-node-method="filterNode"
		/>
	</div>
</template>

<script lang="ts" setup>


import { AsamInput, AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/filtering.vue

import { ref, watch } from 'vue';

import type {
	AsamInputEmits,
	AsamTreeFilterNodeMethodFunction,
	AsamTreeInstance
} from '@asam-ui/ui';

interface Tree {
	id: number;
	label: string;
	children?: Tree[];
}

const filterText = ref('');
const treeRef = ref<AsamTreeInstance>();

const updateFilterText = (value: AsamInputEmits['update:modelValue'][0]) => {
	filterText.value = String(value);
};

const defaultProps = {
	children: 'children',
	label: 'label'
};

watch(filterText, (val) => {
	treeRef.value!.filter(val);
});

const filterNode: AsamTreeFilterNodeMethodFunction = (value: string, data) => {
	if (!value) return true;
	return data.label.includes(value);
};

const data: Tree[] = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

<style scoped>
/* Keep layout utilities local so the downloaded SFC needs no CSS preset. */
.mb-2 {
	margin-bottom: var(--asam-space-sm);
}
.w-60 {
	width: calc(var(--asam-space-xs) * 60);
}
</style>

<style scoped>
.demo-root-layout {
	display: grid;
	gap: var(--asam-space-md);
	justify-items: start;
}
.demo-root-layout > :is(p, pre, output) {
	margin-block: 0;
}
</style>

许可

vue

<template>
	<div class="demo-root-layout">
		<AsamInput
			:model-value="filterText"
			class="w-60 mb-2"
			placeholder="筛选关键字"
			@update:model-value="updateFilterText"
		/>

		<AsamTree
			ref="treeRef"
			style="max-width: 600px"
			class="filter-tree"
			:data="data"
			:props="defaultProps"
			default-expand-all
			:filter-node-method="filterNode"
		/>
	</div>
</template>

<script setup>


import { AsamInput, AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/filtering.vue
import { ref, watch } from 'vue';
const filterText = ref('');
const treeRef = ref();
const updateFilterText = (value) => {
	filterText.value = String(value);
};
const defaultProps = {
	children: 'children',
	label: 'label'
};
watch(filterText, (val) => {
	treeRef.value.filter(val);
});
const filterNode = (value, data) => {
	if (!value) return true;
	return data.label.includes(value);
};
const data = [
	{
		id: 1,
		label: '一级节点 1',
		children: [
			{
				id: 4,
				label: '二级节点 1-1',
				children: [
					{
						id: 9,
						label: '三级节点 1-1-1'
					},
					{
						id: 10,
						label: '三级节点 1-1-2'
					}
				]
			}
		]
	},
	{
		id: 2,
		label: '一级节点 2',
		children: [
			{
				id: 5,
				label: '二级节点 2-1'
			},
			{
				id: 6,
				label: '二级节点 2-2'
			}
		]
	},
	{
		id: 3,
		label: '一级节点 3',
		children: [
			{
				id: 7,
				label: '二级节点 3-1'
			},
			{
				id: 8,
				label: '二级节点 3-2'
			}
		]
	}
];
</script>

<style scoped>
/* Keep layout utilities local so the downloaded SFC needs no CSS preset. */
.mb-2 {
	margin-bottom: var(--asam-space-sm);
}
.w-60 {
	width: calc(var(--asam-space-xs) * 60);
}
</style>

<style scoped>
.demo-root-layout {
	display: grid;
	gap: var(--asam-space-md);
	justify-items: start;
}
.demo-root-layout > :is(p, pre, output) {
	margin-block: 0;
}
</style>

手风琴效果

对于同一级的节点，每次只能展开一个

手风琴效果

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:data="data"
		:props="defaultProps"
		accordion
		@node-click="handleNodeClick"
	/>
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/accordion.vue

interface Tree {
	label: string;
	children?: Tree[];
}

const handleNodeClick = (data: Tree) => {
	console.log(data);
};

const data: Tree[] = [
	{
		label: '一级节点 1',
		children: [
			{
				label: '二级节点 1-1',
				children: [
					{
						label: '三级节点 1-1-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 2',
		children: [
			{
				label: '二级节点 2-1',
				children: [
					{
						label: '三级节点 2-1-1'
					}
				]
			},
			{
				label: '二级节点 2-2',
				children: [
					{
						label: '三级节点 2-2-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 3',
		children: [
			{
				label: '二级节点 3-1',
				children: [
					{
						label: '三级节点 3-1-1'
					}
				]
			},
			{
				label: '二级节点 3-2',
				children: [
					{
						label: '三级节点 3-2-1'
					}
				]
			}
		]
	}
];
const defaultProps = {
	children: 'children',
	label: 'label'
};
</script>

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:data="data"
		:props="defaultProps"
		accordion
		@node-click="handleNodeClick"
	/>
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
const handleNodeClick = (data) => {
	console.log(data);
};
const data = [
	{
		label: '一级节点 1',
		children: [
			{
				label: '二级节点 1-1',
				children: [
					{
						label: '三级节点 1-1-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 2',
		children: [
			{
				label: '二级节点 2-1',
				children: [
					{
						label: '三级节点 2-1-1'
					}
				]
			},
			{
				label: '二级节点 2-2',
				children: [
					{
						label: '三级节点 2-2-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 3',
		children: [
			{
				label: '二级节点 3-1',
				children: [
					{
						label: '三级节点 3-1-1'
					}
				]
			},
			{
				label: '二级节点 3-2',
				children: [
					{
						label: '三级节点 3-2-1'
					}
				]
			}
		]
	}
];
const defaultProps = {
	children: 'children',
	label: 'label'
};
</script>

可拖放

通过 draggable 属性可让节点变为可拖拽

可拖放

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:allow-drop="allowDrop"
		:allow-drag="allowDrag"
		:data="data"
		draggable
		default-expand-all
		node-key="id"
		@node-drag-start="handleDragStart"
		@node-drag-enter="handleDragEnter"
		@node-drag-leave="handleDragLeave"
		@node-drag-over="handleDragOver"
		@node-drag-end="handleDragEnd"
		@node-drop="handleDrop"
	/>
</template>

<script lang="ts" setup>


import { AsamTree } from '@asam-ui/ui';
// Adapted from the fixed upstream MIT example: tree/draggable.vue

import type {
	AsamTreeAllowDropType,
	AsamTreeNodeDropType,
	AsamTreeRenderContentContext
} from '@asam-ui/ui';

type Node = AsamTreeRenderContentContext['node'];

const handleDragStart = (node: Node, _event: DragEvent) => {
	console.log('drag start', node);
};
const handleDragEnter = (draggingNode: Node, dropNode: Node, _event: DragEvent) => {
	console.log('tree drag enter:', dropNode.label);
};
const handleDragLeave = (draggingNode: Node, dropNode: Node, _event: DragEvent) => {
	console.log('tree drag leave:', dropNode.label);
};
const handleDragOver = (draggingNode: Node, dropNode: Node, _event: DragEvent) => {
	console.log('tree drag over:', dropNode.label);
};
const handleDragEnd = (
	draggingNode: Node,
	dropNode: Node | null,
	dropType: AsamTreeNodeDropType,
	_event: DragEvent
) => {
	console.log('tree drag end:', dropNode && dropNode.label, dropType);
};
const handleDrop = (
	draggingNode: Node,
	dropNode: Node,
	dropType: Exclude<AsamTreeNodeDropType, 'none'>,
	_event: DragEvent
) => {
	console.log('tree drop:', dropNode.label, dropType);
};
const allowDrop = (draggingNode: Node, dropNode: Node, type: AsamTreeAllowDropType) => {
	if (dropNode.data.label === '二级节点 3-1') {
		return type !== 'inner';
	} else {
		return true;
	}
};
const allowDrag = (draggingNode: Node) => {
	return !draggingNode.data.label.includes('三级节点 3-1-1');
};

const data = [
	{
		label: '一级节点 1',
		children: [
			{
				label: '二级节点 1-1',
				children: [
					{
						label: '三级节点 1-1-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 2',
		children: [
			{
				label: '二级节点 2-1',
				children: [
					{
						label: '三级节点 2-1-1'
					}
				]
			},
			{
				label: '二级节点 2-2',
				children: [
					{
						label: '三级节点 2-2-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 3',
		children: [
			{
				label: '二级节点 3-1',
				children: [
					{
						label: '三级节点 3-1-1'
					}
				]
			},
			{
				label: '二级节点 3-2',
				children: [
					{
						label: '三级节点 3-2-1'
					}
				]
			}
		]
	}
];
</script>

许可

vue

<template>
	<AsamTree
		style="max-width: 600px"
		:allow-drop="allowDrop"
		:allow-drag="allowDrag"
		:data="data"
		draggable
		default-expand-all
		node-key="id"
		@node-drag-start="handleDragStart"
		@node-drag-enter="handleDragEnter"
		@node-drag-leave="handleDragLeave"
		@node-drag-over="handleDragOver"
		@node-drag-end="handleDragEnd"
		@node-drop="handleDrop"
	/>
</template>

<script setup>


import { AsamTree } from '@asam-ui/ui';
const handleDragStart = (node, _event) => {
	console.log('drag start', node);
};
const handleDragEnter = (draggingNode, dropNode, _event) => {
	console.log('tree drag enter:', dropNode.label);
};
const handleDragLeave = (draggingNode, dropNode, _event) => {
	console.log('tree drag leave:', dropNode.label);
};
const handleDragOver = (draggingNode, dropNode, _event) => {
	console.log('tree drag over:', dropNode.label);
};
const handleDragEnd = (draggingNode, dropNode, dropType, _event) => {
	console.log('tree drag end:', dropNode && dropNode.label, dropType);
};
const handleDrop = (draggingNode, dropNode, dropType, _event) => {
	console.log('tree drop:', dropNode.label, dropType);
};
const allowDrop = (draggingNode, dropNode, type) => {
	if (dropNode.data.label === '二级节点 3-1') {
		return type !== 'inner';
	} else {
		return true;
	}
};
const allowDrag = (draggingNode) => {
	return !draggingNode.data.label.includes('三级节点 3-1-1');
};
const data = [
	{
		label: '一级节点 1',
		children: [
			{
				label: '二级节点 1-1',
				children: [
					{
						label: '三级节点 1-1-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 2',
		children: [
			{
				label: '二级节点 2-1',
				children: [
					{
						label: '三级节点 2-1-1'
					}
				]
			},
			{
				label: '二级节点 2-2',
				children: [
					{
						label: '三级节点 2-2-1'
					}
				]
			}
		]
	},
	{
		label: '一级节点 3',
		children: [
			{
				label: '二级节点 3-1',
				children: [
					{
						label: '三级节点 3-1-1'
					}
				]
			},
			{
				label: '二级节点 3-2',
				children: [
					{
						label: '三级节点 3-2-1'
					}
				]
			}
		]
	}
];
</script>

Tree API

属性

名称	说明	类型	默认值
data	展示数据	array`Array<{[key: string]: any}>`	—
empty-text	内容为空的时候展示的文本	string	—
node-key	每个树节点用来作为唯一标识的属性，在整棵树中应该是唯一的	string	—
props	配置选项，具体看下表	object	—
render-after-expand	是否在第一次展开某个树节点后才渲染其子节点	boolean	true
load	加载子树数据的方法，仅当 lazy 属性为true 时生效	Function`(node, resolve, reject) => void`	—
render-content	树节点的内容区的渲染 Function	Function`(h, { node, data, store }) => void`	—
highlight-current	是否高亮当前选中节点	boolean	false
default-expand-all	是否默认展开所有节点	boolean	false
expand-on-click-node	是否在点击节点的时候展开或者收缩节点，默认值为 true，如果为 false，则只有点箭头图标的时候才会展开或者收缩节点	boolean	true
check-on-click-node	是否在点击节点的时候选中节点，默认值为 false，即只有在点击复选框时才会选中节点	boolean	false
check-on-click-leaf	点击叶节点(最后一个子节点)时是否检查或取消节点	boolean	true
auto-expand-parent	展开子节点的时候是否自动展开父节点	boolean	true
default-expanded-keys	默认展开的节点的 key 的数组	array`Array<string \| number>`	—
show-checkbox	节点是否可被选择	boolean	false
check-strictly	在显示复选框的情况下，是否严格的遵循父子不互相关联的做法，默认为 false	boolean	false
default-checked-keys	默认勾选的节点的 key 的数组	array`Array<string \| number>`	—
current-node-key	当前选中的节点	string / number	—
filter-node-method	对树节点进行筛选时执行的方法，返回 true 表示这个节点可以显示，返回 false 则表示这个节点会被隐藏	Function`(value, data, node) => boolean`	—
accordion	是否每次只打开一个同级树节点展开	boolean	false
indent	相邻级节点间的水平缩进，单位为像素	number	18
icon	自定义树节点图标组件	string / Component	—
lazy	是否懒加载子节点，需与 load 方法结合使用	boolean	false
draggable	是否开启拖拽节点功能	boolean	false
allow-drag	判断节点能否被拖拽如果返回 false ，节点不能被拖动	Function`(node) => boolean`	—
allow-drop	拖拽时判定目标节点能否成为拖动目标位置。如果返回 false ，拖动节点不能被拖放到目标节点。 type 参数有三种情况：'prev'、'inner' 和 'next'，分别表示放置在目标节点前、插入至目标节点和放置在目标节点后	Function`(draggingNode, dropNode, type) => boolean`	—

节点字段映射

属性	说明	类型	默认值
label	指定节点标签为节点对象的某个属性值	string / Function`(data, node) => string`	—
children	指定子树为节点对象的某个属性值	string	—
disabled	指定节点选择框是否禁用为节点对象的某个属性值	string / Function`(data, node) => boolean`	—
isLeaf	指定节点是否为叶子节点，仅在指定了 lazy 属性的情况下生效	string / Function`(data, node) => boolean`	—
class	自定义节点类名	string / Function`(data, node) => string`	—

暴露

Tree 组件有以下方法，均返回当前选中的节点数组

方法	说明	参数
filter	过滤所有树节点，过滤后的节点将被隐藏	接收一个参数，作为 filter-node-method 的第一个参数。
updateKeyChildren	为节点设置新数据，只有当设置 node-key 属性的时候才可用	(key, data)：节点的 key 与新的节点数据。
getCheckedNodes	如果节点可以被选中，(show-checkbox 为 true), 本方法将返回当前选中节点的数组	(leafOnly, includeHalfChecked)：两个布尔参数，默认均为 false。leafOnly 为 true 时仅返回选中的叶子节点；includeHalfChecked 为 true 时包含半选节点。
setCheckedNodes	设置目前选中的节点，使用此方法必须设置 node-key 属性	(nodes, leafOnly)：待选中的节点对象数组与布尔参数。leafOnly 默认 false；为 true 时仅设置叶子节点的选中状态。
getCheckedKeys	若节点可用被选中 (show-checkbox 为 true), 它将返回当前选中节点 key 的数组	(leafOnly)：布尔参数，默认 false；为 true 时仅返回选中叶子节点的 key。
setCheckedKeys	设置目前选中的节点，使用此方法必须设置 node-key 属性	(keys, leafOnly)：待选中节点的 key 数组与布尔参数。leafOnly 默认 false；为 true 时仅设置叶子节点的选中状态。
setChecked	设置节点是否被选中, 使用此方法必须设置 node-key 属性	(key/data, checked, deep)：节点 key 或数据、是否选中，以及是否递归设置子节点。递归设置不受 check-strictly 限制。
getHalfCheckedNodes	如果节点可用被选中 (show-checkbox 为 true), 它将返回当前半选中的节点组成的数组	—
getHalfCheckedKeys	若节点可被选中(show-checkbox 为 true)，则返回目前半选中的节点的 key 所组成的数组	—
getCurrentKey	返回当前被选中节点的数据 (如果没有则返回 null)	—
getCurrentNode	返回当前被选中节点的数据 (如果没有则返回 null)	—
setCurrentKey	通过 key 设置某个节点的当前选中状态，使用此方法必须设置 node-key 属性	(key, shouldAutoExpandParent=true)：待高亮节点的 key；传入 null 时取消高亮。第二个参数控制是否自动展开父节点。
setCurrentNode	设置节点为选中状态，使用此方法必须设置 node-key 属性	(node, shouldAutoExpandParent=true)：待高亮节点，以及是否自动展开父节点。
getNode	根据 data 或者 key 拿到 Tree 组件中的 node	(data)：节点数据或 key。
remove	删除 Tree 中的一个节点，使用此方法必须设置 node-key 属性	(data)：待删除节点的数据或节点对象。
append	为 Tree 中的一个节点追加一个子节点	(data, parentNode)：待追加子节点的数据，以及父节点的数据、key 或节点对象。
insertBefore	在 Tree 中给定节点前插入一个节点	(data, refNode)：待插入节点的数据，以及参照节点的数据、key 或节点对象。
insertAfter	在 Tree 中给定节点后插入一个节点	(data, refNode)：待插入节点的数据，以及参照节点的数据、key 或节点对象。

事件

名称	说明	参数
node-click	当节点被点击的时候触发	四个参数：被点击节点的数据、AsamTreeRenderContentContext['node'] 对应的节点、上下文本身，以及事件对象。
node-contextmenu	当某一节点被鼠标右键点击时会触发该事件	四个参数：事件对象、被点击节点的数据、AsamTreeRenderContentContext['node'] 对应的节点，以及上下文本身。
check-change	当复选框被点击的时候触发	三个参数：状态变化节点的数据、节点是否选中，以及节点的子树中是否存在选中节点。
check	点击节点复选框之后触发	两个参数：选中或取消选中节点的数据，以及包含 checkedNodes、checkedKeys、halfCheckedNodes、halfCheckedKeys 的树选中状态对象。
current-change	当前选中节点变化时触发的事件	两个参数：当前节点的数据，以及 AsamTreeRenderContentContext['node'] 对应的节点。
node-expand	节点被展开时触发的事件	三个参数：展开节点的数据、AsamTreeRenderContentContext['node'] 对应的节点，以及上下文本身。
node-collapse	节点被关闭时触发的事件	三个参数：收起节点的数据、AsamTreeRenderContentContext['node'] 对应的节点，以及上下文本身。
node-drag-start	节点开始拖拽时触发的事件	两个参数：被拖拽节点的数据与事件对象。
node-drag-enter	拖拽进入其他节点时触发的事件	三个参数：被拖拽节点的数据、拖拽进入节点的数据，以及事件对象。
node-drag-leave	拖拽离开某个节点时触发的事件	三个参数：被拖拽节点的数据、拖拽离开节点的数据，以及事件对象。
node-drag-over	在拖拽节点时触发的事件（类似浏览器的 mouseover 事件）	三个参数：被拖拽节点的数据、拖拽经过节点的数据，以及事件对象。
node-drag-end	拖拽结束时（可能未成功）触发的事件	四个参数：被拖拽节点的数据、拖拽结束节点的数据（可能为 undefined）、放置类型 before / after / inner，以及事件对象。
node-drop	拖拽成功完成时触发的事件	四个参数：被拖拽节点的数据、放置目标节点的数据、放置类型 before / after / inner，以及事件对象。

插槽

名称	说明	类型
default	自定义树节点的内容。	object`{ node: UnwrapRef<RootTreeType['root']>, data: Tree \| TreeOptionProps }`
empty	当数据为空时自定义的内容	—

API

属性 `AsamTreeProps`

属性名	说明	类型	默认值
`props`	配置选项，具体看下表	`AsamTreeOptionProps \| undefined`	`工厂函数（每个实例创建）`
`data`	展示数据	`AsamTreeData \| undefined`	`工厂函数（每个实例创建）`
`lazy`	是否懒加载子节点，需与 load 方法结合使用	`boolean \| undefined`	`false`
`checkStrictly`	在显示复选框的情况下，是否严格的遵循父子不互相关联的做法，默认为 false	`boolean \| undefined`	`false`
`autoExpandParent`	展开子节点的时候是否自动展开父节点	`(AsamTreeProps)["autoExpandParent"]`	`true`
`defaultExpandAll`	是否默认展开所有节点	`boolean \| undefined`	`false`
`checkDescendants`	—	`boolean \| undefined`	`false`
`checkOnClickNode`	是否在点击节点的时候选中节点，默认值为 false，即只有在点击复选框时才会选中节点	`boolean \| undefined`	`false`
`checkOnClickLeaf`	点击叶节点(最后一个子节点)时是否检查或取消节点	`(AsamTreeProps)["checkOnClickLeaf"]`	`true`
`accordion`	是否每次只打开一个同级树节点展开	`boolean \| undefined`	`false`
`draggable`	是否开启拖拽节点功能	`boolean \| undefined`	`false`
`indent`	相邻级节点间的水平缩进，单位为像素	`number \| undefined`	`18`
`renderAfterExpand`	是否在第一次展开某个树节点后才渲染其子节点	`(AsamTreeProps)["renderAfterExpand"]`	`true`
`showCheckbox`	节点是否可被选择	`boolean \| undefined`	`false`
`expandOnClickNode`	是否在点击节点的时候展开或者收缩节点，默认值为 true，如果为 false，则只有点箭头图标的时候才会展开或者收缩节点	`(AsamTreeProps)["expandOnClickNode"]`	`true`
`highlightCurrent`	是否高亮当前选中节点	`boolean \| undefined`	`false`
`style`	—	`unknown`	—
`emptyText`	内容为空的时候展示的文本	`string \| undefined`	—
`load`	加载子树数据的方法，仅当 lazy 属性为true 时生效	`AsamTreeLoadFunction \| undefined`	—
`onCurrent-change`	—	`((data: any, node: AsamTreeRenderContentContext["node"] \| null) => any) \| undefined`	—
`key`	—	`PropertyKey \| undefined`	—
`ref`	—	`VNodeRef \| undefined`	—
`ref_for`	—	`boolean \| undefined`	—
`ref_key`	—	`string \| undefined`	—
`onVnodeBeforeMount`	—	`(AsamTreeProps)["onVnodeBeforeMount"]`	—
`onVnodeMounted`	—	`(AsamTreeProps)["onVnodeMounted"]`	—
`onVnodeBeforeUpdate`	—	`(AsamTreeProps)["onVnodeBeforeUpdate"]`	—
`onVnodeUpdated`	—	`(AsamTreeProps)["onVnodeUpdated"]`	—
`onVnodeBeforeUnmount`	—	`(AsamTreeProps)["onVnodeBeforeUnmount"]`	—
`onVnodeUnmounted`	—	`(AsamTreeProps)["onVnodeUnmounted"]`	—
`class`	—	`unknown`	—
`icon`	自定义树节点图标组件	`(AsamTreeProps)["icon"]`	—
`nodeKey`	每个树节点用来作为唯一标识的属性，在整棵树中应该是唯一的	`string \| undefined`	—
`defaultCheckedKeys`	默认勾选的节点的 key 的数组	`AsamTreeKey[] \| undefined`	—
`defaultExpandedKeys`	默认展开的节点的 key 的数组	`AsamTreeKey[] \| undefined`	—
`currentNodeKey`	当前选中的节点	`(AsamTreeProps)["currentNodeKey"]`	—
`renderContent`	树节点的内容区的渲染 Function	`AsamTreeRenderContentFunction \| undefined`	—
`allowDrag`	判断节点能否被拖拽如果返回 false ，节点不能被拖动	`AsamTreeAllowDragFunction \| undefined`	—
`allowDrop`	拖拽时判定目标节点能否成为拖动目标位置。如果返回 false ，拖动节点不能被拖放到目标节点。 type 参数有三种情况：'prev'、'inner' 和 'next'，分别表示放置在目标节点前、插入至目标节点和放置在目标节点后	`AsamTreeAllowDropFunction \| undefined`	—
`filterNodeMethod`	对树节点进行筛选时执行的方法，返回 true 表示这个节点可以显示，返回 false 则表示这个节点会被隐藏	`AsamTreeFilterNodeMethodFunction \| undefined`	—
`onCheck-change`	—	`((data: any, checked: boolean, indeterminate: boolean) => any) \| undefined`	—
`onNode-click`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null, evt: MouseEvent) => any) \| undefined`	—
`onNode-contextmenu`	—	`((evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onNode-collapse`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onNode-expand`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onCheck`	—	`((data: any, checkedInfo: AsamTreeCheckedInfo) => any) \| undefined`	—
`onNode-drag-start`	—	`((node: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-end`	—	查看完整类型 `((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] \| null, dropType: AsamTreeNodeDropType, evt: DragEvent) => any) \| undefined`	—
`onNode-drop`	—	查看完整类型 `((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" \| "after" \| "inner", evt: DragEvent) => any) \| undefined`	—
`onNode-drag-leave`	—	`((draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-enter`	—	`((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-over`	—	`((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—

实例方法与状态 `AsamTreeExpose`

属性名	说明	类型	默认值
`$`	—	`AsamTreeExpose["$"]`	—
`$data`	—	`AsamTableColumnExpose`	—
`$props`	—	`AsamTreeProps`	—
`$attrs`	—	`AsamTreeExpose["$attrs"]`	—
`$refs`	—	`AsamTreeExpose["$refs"]`	—
`$slots`	—	`AsamAvatarGroupSlots`	—
`$root`	—	查看完整类型 `ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> \| null`	—
`$parent`	—	查看完整类型 `ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> \| null`	—
`$host`	—	`Element \| null`	—
`$emit`	—	查看完整类型 ((event: "current-change", data: any, node: AsamTreeRenderContentContext["node"] \| null) => void) & ((event: "check-change", data: any, checked: boolean, indeterminate: boolean) => void) & ((event: "node-click", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null, evt: MouseEvent) => void) & ((event: "node-contextmenu", evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => void) & ((event: "node-collapse", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => void) & ((event: "node-expand", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => void) & ((event: "check", data: any, checkedInfo: AsamTreeCheckedInfo) => void) & ((event: "node-drag-start", node: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-end", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] \| null, dropType: AsamTreeNodeDropType, evt: DragEvent) => void) & ((event: "node-drop", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" \| "after" \| "inner", evt: DragEvent) => void) & ((event: "node-drag-leave", draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-enter", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-over", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void)	—
`$el`	—	`any`	—
`$options`	—	`(AsamTreeExpose)["$options"]`	—
`$forceUpdate`	—	`() => void`	—
`$nextTick`	—	`(AsamTreeExpose)["$nextTick"]`	—
`$watch`	—	`(AsamTreeExpose)["$watch"]`	—
`props`	—	`AsamTreeOptionProps`	—
`data`	—	`AsamTreeData`	—
`lazy`	—	`boolean`	—
`checkStrictly`	—	`boolean`	—
`autoExpandParent`	—	`(AsamTreeExpose)["autoExpandParent"]`	—
`defaultExpandAll`	—	`boolean`	—
`checkDescendants`	—	`boolean`	—
`checkOnClickNode`	—	`boolean`	—
`checkOnClickLeaf`	—	`(AsamTreeExpose)["checkOnClickLeaf"]`	—
`accordion`	—	`boolean`	—
`draggable`	—	`boolean`	—
`indent`	—	`number`	—
`renderAfterExpand`	—	`(AsamTreeExpose)["renderAfterExpand"]`	—
`showCheckbox`	—	`boolean`	—
`expandOnClickNode`	—	`(AsamTreeExpose)["expandOnClickNode"]`	—
`highlightCurrent`	—	`boolean`	—
`emptyText`	—	`string \| undefined`	—
`load`	—	`AsamTreeLoadFunction \| undefined`	—
`onCurrent-change`	—	`((data: any, node: AsamTreeRenderContentContext["node"] \| null) => any) \| undefined`	—
`icon`	—	`(AsamTreeExpose)["icon"]`	—
`nodeKey`	—	`string \| undefined`	—
`defaultCheckedKeys`	—	`AsamTreeKey[] \| undefined`	—
`defaultExpandedKeys`	—	`AsamTreeKey[] \| undefined`	—
`currentNodeKey`	—	`(AsamTreeExpose)["currentNodeKey"]`	—
`renderContent`	—	`AsamTreeRenderContentFunction \| undefined`	—
`allowDrag`	—	`AsamTreeAllowDragFunction \| undefined`	—
`allowDrop`	—	`AsamTreeAllowDropFunction \| undefined`	—
`filterNodeMethod`	—	`AsamTreeFilterNodeMethodFunction \| undefined`	—
`onCheck-change`	—	`((data: any, checked: boolean, indeterminate: boolean) => any) \| undefined`	—
`onNode-click`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null, evt: MouseEvent) => any) \| undefined`	—
`onNode-contextmenu`	—	`((evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onNode-collapse`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onNode-expand`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onCheck`	—	`((data: any, checkedInfo: AsamTreeCheckedInfo) => any) \| undefined`	—
`onNode-drag-start`	—	`((node: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-end`	—	查看完整类型 `((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] \| null, dropType: AsamTreeNodeDropType, evt: DragEvent) => any) \| undefined`	—
`onNode-drop`	—	查看完整类型 `((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" \| "after" \| "inner", evt: DragEvent) => any) \| undefined`	—
`onNode-drag-leave`	—	`((draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-enter`	—	`((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-over`	—	`((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`ns`	—	`(AsamTreeExpose)["ns"]`	—
`store`	—	查看完整类型 { currentNode: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; } \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }	—
`root`	—	查看完整类型 { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }	—
`currentNode`	—	查看完整类型 { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; } \| null	—
`dragState`	—	查看完整类型 { allowDrop: boolean; dropType: AsamTreeNodeDropType \| null; draggingNode: { node: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement \| undefined; } \| null; showDropIndicator: boolean; dropNode: { node: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement \| undefined; } \| null; }	—
`el$`	—	`(AsamTreeExpose)["el$"]`	—
`dropIndicator$`	—	`(AsamTreeExpose)["dropIndicator$"]`	—
`isEmpty`	—	`boolean`	—
`filter`	—	`(value: AsamTreeFilterValue) => void`	—
`getNodeKey`	—	`(node: AsamTreeRenderContentContext["node"]) => any`	—
`getNodePath`	—	`(data: AsamTreeKey \| AsamTreeNodeData) => AsamTreeNodeData[]`	—
`getCheckedNodes`	—	`(leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]`	—
`getCheckedKeys`	—	`(leafOnly?: boolean) => AsamTreeKey[]`	—
`getCurrentNode`	—	`() => AsamTreeNodeData \| null`	—
`getCurrentKey`	—	`() => AsamTreeKey \| null`	—
`setCheckedNodes`	—	`(nodes: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void`	—
`setCheckedKeys`	—	`(keys: AsamTreeKey[], leafOnly?: boolean) => void`	—
`setChecked`	—	`(data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep?: boolean) => void`	—
`getHalfCheckedNodes`	—	`() => AsamTreeNodeData[]`	—
`getHalfCheckedKeys`	—	`() => AsamTreeKey[]`	—
`setCurrentNode`	—	`(node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void`	—
`setCurrentKey`	—	`(key?: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void`	—
`t`	—	`AsamTreeExpose["t"]`	—
`getNode`	—	`(data: AsamTreeKey \| AsamTreeNodeData) => AsamTreeRenderContentContext["node"]`	—
`remove`	—	`(data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void`	—
`append`	—	`(data: AsamTreeNodeData, parentNode: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void`	—
`insertBefore`	—	`(data: AsamTreeNodeData, refNode: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void`	—
`insertAfter`	—	`(data: AsamTreeNodeData, refNode: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void`	—
`handleNodeExpand`	—	`(nodeData: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"], instance: AsamTreeExpose["$"]) => void`	—
`updateKeyChildren`	—	`(key: AsamTreeKey, data: AsamTreeData) => void`	—
`$route`	当前规范化路由位置，详见 RouteLocationNormalizedLoaded。	`AsamTreeExpose["$route"]`	—
`$router`	应用使用的 Router 实例。	`AsamTreeExpose["$router"]`	—

类型 `AsamTreeInstance`

属性名	说明	类型	默认值
`$`	—	`AsamTreeExpose["$"]`	—
`$data`	—	`AsamTableColumnExpose`	—
`$props`	—	`AsamTreeProps`	—
`$attrs`	—	`AsamTreeExpose["$attrs"]`	—
`$refs`	—	`AsamTreeExpose["$refs"]`	—
`$slots`	—	`AsamAvatarGroupSlots`	—
`$root`	—	查看完整类型 `ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> \| null`	—
`$parent`	—	查看完整类型 `ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> \| null`	—
`$host`	—	`Element \| null`	—
`$emit`	—	查看完整类型 ((event: "current-change", data: any, node: AsamTreeRenderContentContext["node"] \| null) => void) & ((event: "check-change", data: any, checked: boolean, indeterminate: boolean) => void) & ((event: "node-click", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null, evt: MouseEvent) => void) & ((event: "node-contextmenu", evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => void) & ((event: "node-collapse", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => void) & ((event: "node-expand", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => void) & ((event: "check", data: any, checkedInfo: AsamTreeCheckedInfo) => void) & ((event: "node-drag-start", node: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-end", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] \| null, dropType: AsamTreeNodeDropType, evt: DragEvent) => void) & ((event: "node-drop", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" \| "after" \| "inner", evt: DragEvent) => void) & ((event: "node-drag-leave", draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-enter", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-over", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void)	—
`$el`	—	`any`	—
`$options`	—	`(AsamTreeInstance)["$options"]`	—
`$forceUpdate`	—	`() => void`	—
`$nextTick`	—	`(AsamTreeInstance)["$nextTick"]`	—
`$watch`	—	`(AsamTreeInstance)["$watch"]`	—
`props`	—	`AsamTreeOptionProps`	—
`data`	—	`AsamTreeData`	—
`lazy`	—	`boolean`	—
`checkStrictly`	—	`boolean`	—
`autoExpandParent`	—	`(AsamTreeInstance)["autoExpandParent"]`	—
`defaultExpandAll`	—	`boolean`	—
`checkDescendants`	—	`boolean`	—
`checkOnClickNode`	—	`boolean`	—
`checkOnClickLeaf`	—	`(AsamTreeInstance)["checkOnClickLeaf"]`	—
`accordion`	—	`boolean`	—
`draggable`	—	`boolean`	—
`indent`	—	`number`	—
`renderAfterExpand`	—	`(AsamTreeInstance)["renderAfterExpand"]`	—
`showCheckbox`	—	`boolean`	—
`expandOnClickNode`	—	`(AsamTreeInstance)["expandOnClickNode"]`	—
`highlightCurrent`	—	`boolean`	—
`emptyText`	—	`string \| undefined`	—
`load`	—	`AsamTreeLoadFunction \| undefined`	—
`onCurrent-change`	—	`((data: any, node: AsamTreeRenderContentContext["node"] \| null) => any) \| undefined`	—
`icon`	—	`(AsamTreeInstance)["icon"]`	—
`nodeKey`	—	`string \| undefined`	—
`defaultCheckedKeys`	—	`AsamTreeKey[] \| undefined`	—
`defaultExpandedKeys`	—	`AsamTreeKey[] \| undefined`	—
`currentNodeKey`	—	`(AsamTreeInstance)["currentNodeKey"]`	—
`renderContent`	—	`AsamTreeRenderContentFunction \| undefined`	—
`allowDrag`	—	`AsamTreeAllowDragFunction \| undefined`	—
`allowDrop`	—	`AsamTreeAllowDropFunction \| undefined`	—
`filterNodeMethod`	—	`AsamTreeFilterNodeMethodFunction \| undefined`	—
`onCheck-change`	—	`((data: any, checked: boolean, indeterminate: boolean) => any) \| undefined`	—
`onNode-click`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null, evt: MouseEvent) => any) \| undefined`	—
`onNode-contextmenu`	—	`((evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onNode-collapse`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onNode-expand`	—	`((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] \| null) => any) \| undefined`	—
`onCheck`	—	`((data: any, checkedInfo: AsamTreeCheckedInfo) => any) \| undefined`	—
`onNode-drag-start`	—	`((node: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-end`	—	查看完整类型 `((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] \| null, dropType: AsamTreeNodeDropType, evt: DragEvent) => any) \| undefined`	—
`onNode-drop`	—	查看完整类型 `((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" \| "after" \| "inner", evt: DragEvent) => any) \| undefined`	—
`onNode-drag-leave`	—	`((draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-enter`	—	`((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`onNode-drag-over`	—	`((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) \| undefined`	—
`ns`	—	`(AsamTreeInstance)["ns"]`	—
`store`	—	查看完整类型 { currentNode: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; } \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }	—
`root`	—	查看完整类型 { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }	—
`currentNode`	—	查看完整类型 { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; } \| null	—
`dragState`	—	查看完整类型 { allowDrop: boolean; dropType: AsamTreeNodeDropType \| null; draggingNode: { node: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement \| undefined; } \| null; showDropIndicator: boolean; dropNode: { node: { id: number; text: string \| null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any \| null; visible: boolean; isCurrent: boolean; store: { currentNode: any \| null; currentNodeKey: AsamTreeKey \| null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction \| undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction \| undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] \| undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] \| undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string \| undefined; label?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined; disabled?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; isLeaf?: string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean \| undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] \| null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean \| undefined; isLeaf: boolean \| undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey \| null \| undefined; readonly disabled: boolean; readonly nextSibling: any \| null; readonly previousSibling: any \| null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode \| AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData \| null) => void; expand: (callback?: (() => void) \| null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean \| string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData \| AsamTreeNodeData[] \| null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement \| undefined; } \| null; }	—
`el$`	—	`(AsamTreeInstance)["el$"]`	—
`dropIndicator$`	—	`(AsamTreeInstance)["dropIndicator$"]`	—
`isEmpty`	—	`boolean`	—
`filter`	—	`(value: AsamTreeFilterValue) => void`	—
`getNodeKey`	—	`(node: AsamTreeRenderContentContext["node"]) => any`	—
`getNodePath`	—	`(data: AsamTreeKey \| AsamTreeNodeData) => AsamTreeNodeData[]`	—
`getCheckedNodes`	—	`(leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]`	—
`getCheckedKeys`	—	`(leafOnly?: boolean) => AsamTreeKey[]`	—
`getCurrentNode`	—	`() => AsamTreeNodeData \| null`	—
`getCurrentKey`	—	`() => AsamTreeKey \| null`	—
`setCheckedNodes`	—	`(nodes: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void`	—
`setCheckedKeys`	—	`(keys: AsamTreeKey[], leafOnly?: boolean) => void`	—
`setChecked`	—	`(data: AsamTreeKey \| AsamTreeNodeData, checked: boolean, deep?: boolean) => void`	—
`getHalfCheckedNodes`	—	`() => AsamTreeNodeData[]`	—
`getHalfCheckedKeys`	—	`() => AsamTreeKey[]`	—
`setCurrentNode`	—	`(node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void`	—
`setCurrentKey`	—	`(key?: AsamTreeKey \| null, shouldAutoExpandParent?: boolean) => void`	—
`t`	—	`AsamTreeExpose["t"]`	—
`getNode`	—	`(data: AsamTreeKey \| AsamTreeNodeData) => AsamTreeRenderContentContext["node"]`	—
`remove`	—	`(data: AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void`	—
`append`	—	`(data: AsamTreeNodeData, parentNode: AsamTreeNodeData \| AsamTreeKey \| AsamTreeRenderContentContext["node"]) => void`	—
`insertBefore`	—	`(data: AsamTreeNodeData, refNode: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void`	—
`insertAfter`	—	`(data: AsamTreeNodeData, refNode: AsamTreeKey \| AsamTreeNodeData \| AsamTreeRenderContentContext["node"]) => void`	—
`handleNodeExpand`	—	`(nodeData: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"], instance: AsamTreeExpose["$"]) => void`	—
`updateKeyChildren`	—	`(key: AsamTreeKey, data: AsamTreeData) => void`	—
`$route`	当前规范化路由位置，详见 RouteLocationNormalizedLoaded。	`AsamTreeExpose["$route"]`	—
`$router`	应用使用的 Router 实例。	`AsamTreeExpose["$router"]`	—

插槽 `AsamTreeSlots`

属性名	说明	类型	默认值
`default`	—	`((scope: Pick<AsamTreeRenderContentContext, "node" \| "data">) => VNode[]) \| undefined`	—
`empty`	—	`(() => VNode[]) \| undefined`	—

类型 `AsamTreeAllowDragFunction`

(node: AsamTreeRenderContentContext["node"]): boolean

类型 `AsamTreeAllowDropFunction`

(draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], type: AsamTreeAllowDropType): boolean

类型 `AsamTreeAllowDropType`

类型 `AsamTreeCheckedInfo`

属性名	说明	类型	默认值
`checkedKeys`	—	`AsamTreeKey[]`	—
`checkedNodes`	—	`AsamTreeData`	—
`halfCheckedKeys`	—	`AsamTreeKey[]`	—
`halfCheckedNodes`	—	`AsamTreeData`	—

类型 `AsamTreeDragEvents`

属性名	说明	类型	默认值
`treeNodeDragStart`	—	`(AsamTreeDragEvents)["treeNodeDragStart"]`	—
`treeNodeDragOver`	—	`(AsamTreeDragEvents)["treeNodeDragOver"]`	—
`treeNodeDragEnd`	—	`(event: DragEvent) => void`	—

类型 `AsamTreeFakeNode`

属性名	说明	类型	默认值
`data`	—	`AsamTreeNodeData`	—

类型 `AsamTreeFilterNodeMethodFunction`

(value: any, data: AsamTreeNodeData, child: AsamTreeRenderContentContext["node"]): boolean

类型 `AsamTreeFilterValue`

类型 `AsamTreeLoadFunction`

(rootNode: AsamTreeRenderContentContext["node"], loadedCallback: (data: AsamTreeData) => void, stopLoading: () => void): void

类型 `AsamTreeNodeDropType`

类型 `AsamTreeRenderContentContext`

属性名	说明	类型	默认值
`_self`	—	`AsamTreeExpose["$"]`	—
`node`	—	`AsamTreeRenderContentContext["node"]`	—
`data`	—	`AsamTreeNodeData`	—
`store`	—	`AsamTreeRenderContentContext["store"]`	—

类型 `AsamTreeRenderContentFunction`

查看完整调用签名

(h: Parameters<AsamTreeRenderContentFunction>[0], context: AsamTreeRenderContentContext): VNode<import("vue").RendererNode, import("vue").RendererElement, { [key: string]: any; }> | VNode<import("vue").RendererNode, import("vue").RendererElement, { [key: string]: any; }>[]

类型 `AsamTreeRootTreeType`

属性名	说明	类型	默认值
`ctx`	—	`(AsamTreeRootTreeType)["ctx"]`	—
`props`	—	`AsamTreeComponentProps`	—
`store`	—	`Ref<AsamTreeRenderContentContext["store"], AsamTreeRenderContentContext["store"]>`	—
`root`	—	`Ref<AsamTreeRenderContentContext["node"], AsamTreeRenderContentContext["node"]>`	—
`currentNode`	—	`Ref<AsamTreeRenderContentContext["node"], AsamTreeRenderContentContext["node"]>`	—
`instance`	—	`AsamTreeExpose["$"]`	—

类型 `AsamTreeComponentProps`

属性名	说明	类型	默认值
`data`	—	`AsamTreeData`	—
`emptyText`	—	`string`	—
`renderAfterExpand`	—	`boolean`	—
`nodeKey`	—	`string`	—
`checkStrictly`	—	`boolean`	—
`expandOnClickNode`	—	`boolean`	—
`defaultExpandAll`	—	`boolean`	—
`checkOnClickNode`	—	`boolean`	—
`checkOnClickLeaf`	—	`boolean`	—
`checkDescendants`	—	`boolean`	—
`autoExpandParent`	—	`boolean`	—
`defaultCheckedKeys`	—	`AsamTreeKey[]`	—
`defaultExpandedKeys`	—	`AsamTreeKey[]`	—
`currentNodeKey`	—	`AsamTreeKey`	—
`renderContent`	—	`AsamTreeRenderContentFunction`	—
`showCheckbox`	—	`boolean`	—
`draggable`	—	`boolean`	—
`allowDrag`	—	`AsamTreeAllowDragFunction`	—
`allowDrop`	—	`AsamTreeAllowDropFunction`	—
`props`	—	`AsamTreeOptionProps`	—
`lazy`	—	`boolean`	—
`highlightCurrent`	—	`boolean`	—
`load`	—	`AsamTreeLoadFunction`	—
`filterNodeMethod`	—	`AsamTreeFilterNodeMethodFunction`	—
`accordion`	—	`boolean`	—
`indent`	—	`number`	—
`icon`	—	`string \| Component`	—

类型 `AsamTreeData`

属性名	说明	类型	默认值
`length`	获取或设置数组长度，等于最高索引加一。	`number`	—
`toString`	返回数组的字符串表示。	`() => string`	`undefined`
`toLocaleString`	通过各元素的 toLocaleString 方法返回数组的本地化字符串。	`(AsamTreeData)["toLocaleString"]`	`undefined`
`pop`	移除并返回最后一个元素；空数组返回 undefined 且不修改数组。	`() => AsamTreeNodeData \| undefined`	—
`push`	在末尾追加元素并返回新的数组长度。	`(...items: AsamTreeNodeData[]) => number`	—
`concat`	合并数组，返回新数组而不修改原数组。	`{ (...items: ConcatArray<AsamTreeNodeData>[]): AsamTreeNodeData[]; (...items: (AsamTreeNodeData \| ConcatArray<AsamTreeNodeData>)[]): AsamTreeNodeData[]; }`	—
`join`	以指定分隔符连接所有数组元素。	`(separator?: string) => string`	—
`reverse`	原地反转数组，并返回同一数组引用。	`() => AsamTreeNodeData[]`	—
`shift`	移除并返回首个元素；空数组返回 undefined 且不修改数组。	`() => AsamTreeNodeData \| undefined`	—
`slice`	返回数组区间的副本；起止位置支持负索引，例如 -2 表示倒数第二项。	`(start?: number, end?: number) => AsamTreeNodeData[]`	—
`sort`	原地排序数组，并返回同一数组引用。	`(compareFn?: ((a: AsamTreeNodeData, b: AsamTreeNodeData) => number) \| undefined) => AsamTreeData`	—
`splice`	删除并可插入元素，返回被删除的元素。	`{ (start: number, deleteCount?: number): AsamTreeNodeData[]; (start: number, deleteCount: number, ...items: AsamTreeNodeData[]): AsamTreeNodeData[]; }`	—
`unshift`	在开头插入元素并返回新长度。	`(...items: AsamTreeNodeData[]) => number`	—
`indexOf`	返回值首次出现的索引，不存在时返回 -1。	`(searchElement: AsamTreeNodeData, fromIndex?: number) => number`	—
`lastIndexOf`	返回值最后出现的索引，不存在时返回 -1。	`(searchElement: AsamTreeNodeData, fromIndex?: number) => number`	—
`every`	判断全部元素是否满足指定条件。	查看完整类型 `{ <S extends AsamTreeNodeData>(predicate: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => unknown, thisArg?: any): boolean; }`	—
`some`	判断是否至少有一个元素满足指定条件。	`(predicate: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => unknown, thisArg?: any) => boolean`	—
`forEach`	对各元素执行指定操作。	`(callbackfn: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => void, thisArg?: any) => void`	—
`map`	对各元素调用回调并返回结果数组。	`<U>(callbackfn: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => U, thisArg?: any) => U[]`	—
`filter`	返回满足回调条件的元素。	查看完整类型 `{ <S extends AsamTreeNodeData>(predicate: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => value is S, thisArg?: any): S[]; (predicate: (value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => unknown, thisArg?: any): AsamTreeNodeData[]; }`	—
`reduce`	按升序对各元素进行归约，将累计结果传给下一次回调。	`(AsamTreeData)["reduce"]`	—
`reduceRight`	按降序对各元素进行归约，将累计结果传给下一次回调。	`(AsamTreeData)["reduceRight"]`	—
`find`	返回第一个满足条件的元素，否则返回 undefined。	查看完整类型 `{ <S extends AsamTreeNodeData>(predicate: (value: AsamTreeNodeData, index: number, obj: AsamTreeNodeData[]) => value is S, thisArg?: any): S \| undefined; (predicate: (value: AsamTreeNodeData, index: number, obj: AsamTreeNodeData[]) => unknown, thisArg?: any): AsamTreeNodeData \| undefined; }`	—
`findIndex`	返回第一个满足条件的索引，否则返回 -1。	`(predicate: (value: AsamTreeNodeData, index: number, obj: AsamTreeNodeData[]) => unknown, thisArg?: any) => number`	—
`fill`	将 start 至 end 区间的元素替换为固定值并返回数组。	`(value: AsamTreeNodeData, start?: number, end?: number) => AsamTreeData`	—
`copyWithin`	将 start 至 end 区间复制到同一数组的 target 位置，并返回该数组。	`(target: number, start: number, end?: number) => AsamTreeData`	—
`entries`	返回各项键值对的迭代器。	`() => ArrayIterator<[number, AsamTreeNodeData]>`	—
`keys`	返回数组键的迭代器。	`() => ArrayIterator<number>`	—
`values`	返回数组值的迭代器。	`() => ArrayIterator<AsamTreeNodeData>`	—
`includes`	判断数组是否包含指定元素。	`(searchElement: AsamTreeNodeData, fromIndex?: number) => boolean`	—
`flatMap`	映射各元素并将结果展开一层，相当于先 map 再 flat(1)。	查看完整类型 `<U, This = undefined>(callback: (this: This, value: AsamTreeNodeData, index: number, array: AsamTreeNodeData[]) => U \| readonly U[], thisArg?: This \| undefined) => U[]`	—
`flat`	按指定深度递归展开子数组，返回新数组。	`<A, D extends number = 1>(this: A, depth?: D \| undefined) => FlatArray<A, D>[]`	—
`at`	返回指定索引处的元素。	`(index: number) => AsamTreeNodeData \| undefined`	—
`[Symbol.iterator]`	迭代器。	`() => ArrayIterator<AsamTreeNodeData>`	—
`[Symbol.unscopables]`	在 with 语句中应排除的属性，其对应值为 true。	查看完整类型 { [x: number]: boolean \| undefined; length?: boolean \| undefined; toString?: boolean \| undefined; toLocaleString?: boolean \| undefined; pop?: boolean \| undefined; push?: boolean \| undefined; concat?: boolean \| undefined; join?: boolean \| undefined; reverse?: boolean \| undefined; shift?: boolean \| undefined; slice?: boolean \| undefined; sort?: boolean \| undefined; splice?: boolean \| undefined; unshift?: boolean \| undefined; indexOf?: boolean \| undefined; lastIndexOf?: boolean \| undefined; every?: boolean \| undefined; some?: boolean \| undefined; forEach?: boolean \| undefined; map?: boolean \| undefined; filter?: boolean \| undefined; reduce?: boolean \| undefined; reduceRight?: boolean \| undefined; find?: boolean \| undefined; findIndex?: boolean \| undefined; fill?: boolean \| undefined; copyWithin?: boolean \| undefined; entries?: boolean \| undefined; keys?: boolean \| undefined; values?: boolean \| undefined; includes?: boolean \| undefined; flatMap?: boolean \| undefined; flat?: boolean \| undefined; at?: boolean \| undefined; [Symbol.iterator]?: boolean \| undefined; readonly [Symbol.unscopables]?: boolean \| undefined; }	—

事件 `AsamTreeEmits`

(event: "current-change", ...args: [data: any, node: AsamTreeRenderContentContext["node"] | null]): void

(event: "check-change", ...args: [data: any, checked: boolean, indeterminate: boolean]): void

(event: "node-click", ...args: [data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null, evt: MouseEvent]): void

查看完整调用签名

(event: "node-contextmenu", ...args: [evt: globalThis.Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null]): void

(event: "node-collapse", ...args: [data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null]): void

(event: "node-expand", ...args: [data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null]): void

(event: "check", ...args: [data: any, checkedInfo: AsamTreeCheckedInfo]): void

(event: "node-drag-start", ...args: [node: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

查看完整调用签名

(event: "node-drag-end", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] | null, dropType: AsamTreeNodeDropType, evt: DragEvent]): void

查看完整调用签名

(event: "node-drop", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" | "after" | "inner", evt: DragEvent]): void

查看完整调用签名

(event: "node-drag-leave", ...args: [draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

(event: "node-drag-enter", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

(event: "node-drag-over", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

类型 `AsamTreeKey`

类型 `AsamTreeNodeChildState`

属性名	说明	类型	默认值
`all`	—	`boolean`	—
`none`	—	`boolean`	—
`allWithoutDisable`	—	`boolean`	—
`half`	—	`boolean`	—
`isEffectivelyChecked`	—	`boolean`	—

类型 `AsamTreeNodeData`

类型 `AsamTreeNodeLoadedDefaultProps`

属性名	说明	类型	默认值
`checked`	—	`boolean \| undefined`	—

类型 `AsamTreeNodeOptions`

属性名	说明	类型	默认值
`data`	展示数据	`AsamTreeNodeData`	—
`store`	—	`AsamTreeRenderContentContext["store"]`	—
`parent`	—	`AsamTreeRenderContentContext["node"] \| undefined`	—

类型 `AsamTreeOptionProps`

属性名	说明	类型	默认值
`children`	—	`string \| undefined`	—
`label`	—	`string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) \| undefined`	—
`disabled`	—	`string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined`	—
`isLeaf`	—	`string \| ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) \| undefined`	—
`class`	—	`((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string \| { [key: string]: boolean; }) \| undefined`	—

类型 `AsamTreeStoreNodesMap`

类型 `AsamTreeStoreOptions`

属性名	说明	类型	默认值
`key`	—	`AsamTreeKey \| undefined`	—
`data`	展示数据	`AsamTreeData`	—
`lazy`	是否懒加载子节点，需与 load 方法结合使用	`boolean`	—
`props`	配置选项，具体看下表	`AsamTreeOptionProps`	—
`load`	加载子树数据的方法，仅当 lazy 属性为true 时生效	`AsamTreeLoadFunction \| undefined`	—
`currentNodeKey`	当前选中的节点	`AsamTreeKey \| undefined`	—
`checkStrictly`	在显示复选框的情况下，是否严格的遵循父子不互相关联的做法，默认为 false	`boolean`	—
`checkDescendants`	—	`boolean`	—
`defaultCheckedKeys`	默认勾选的节点的 key 的数组	`AsamTreeKey[] \| undefined`	—
`defaultExpandedKeys`	默认展开的节点的 key 的数组	`AsamTreeKey[] \| undefined`	—
`autoExpandParent`	展开子节点的时候是否自动展开父节点	`boolean`	—
`defaultExpandAll`	是否默认展开所有节点	`boolean`	—
`filterNodeMethod`	对树节点进行筛选时执行的方法，返回 true 表示这个节点可以显示，返回 false 则表示这个节点会被隐藏	`AsamTreeFilterNodeMethodFunction \| undefined`	—

用法与契约补充说明

使用约定

data 与 props 映射实际 label/children/disabled 等字段；使用勾选和实例节点操作时提供稳定的 nodeKey。showCheckbox、checkStrictly、defaultExpandedKeys/defaultCheckedKeys、lazy/load、draggable、过滤及节点事件按真实契约使用。default 作用域插槽提供 node/data，empty 插槽处理空数据；实例提供选择、过滤与节点更新方法。它与虚拟 TreeV2 的 API 不应互换，远程加载由宿主 load 实现。

自定义节点内容

树节点内容支持 render-content 渲染函数和作用域插槽两种自定义方式。渲染函数返回节点内容，具体语法见 Vue 文档。作用域插槽提供 node 和 data，分别对应 AsamTreeRenderContentContext['node'] 与当前节点数据。使用 JSX 的渲染函数示例不能直接在不支持 JSX 的 JSFiddle 中运行；实际项目需配置相应编译依赖。

参数与事件补充说明

公开绑定参数，包含具备类型的事件监听器；默认值由运行时定义提供。

参数与事件说明

`props`

必填：否；声明来源：上游声明。

props 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

props.children: string | undefined — 上游声明
指定子树为节点对象的某个属性值
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
props.label: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined — 上游声明
指定节点标签为节点对象的某个属性值
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): string
props.disabled: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined — 上游声明
指定节点选择框是否禁用为节点对象的某个属性值
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): boolean
props.isLeaf: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined — 上游声明
指定节点是否为叶子节点，仅在指定了 lazy 属性的情况下生效
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): boolean
props.class: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined — 上游声明
自定义节点类名
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): string | { [key: string]: boolean; }

`emptyText`

必填：否；声明来源：上游声明。

默认值与来源

未知 / 未声明

固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）

`load`

必填：否；声明来源：上游声明。

load 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(rootNode: AsamTreeRenderContentContext["node"], loadedCallback: (data: AsamTreeData) => void, stopLoading: () => void): void

默认值与来源

未知 / 未声明

固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）

`onCurrent-change`

必填：否；声明来源：上游声明。

onCurrent-change 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(data: any, node: AsamTreeRenderContentContext["node"] | null): any

`key`

必填：否；声明来源：依赖声明。

`ref`

必填：否；声明来源：依赖声明。

ref 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(ref: Element | ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> | null, refs: Record<string, any>): void

ref.value: any — 依赖声明
ref.__@RefSymbol@8854: true — 依赖声明
仅用于区分类型：保留在公开声明中，通过私有 Symbol 避免出现在编辑器自动补全中。
枚举：true

`ref_for`

必填：否；声明来源：依赖声明。

ref_for 参数与事件数据

必填：否；声明来源：依赖声明。

`icon`

必填：否；声明来源：上游声明。

icon 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(props: any, ctx: Parameters<Extract<NonNullable<(AsamTreeProps)["icon"]>, (...args: never[]) => unknown>>[1]): any

icon.__isFragment: undefined — 依赖声明
icon.__isTeleport: undefined — 依赖声明
icon.__isSuspense: undefined — 依赖声明

onNode-drag-over 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent): any

AsamTreeProps 公开类型视图

import type { VNodeRef, ComponentPublicInstance, ComponentOptionsBase, ComponentProvideOptions, VNode, RendererNode, RendererElement, Component } from 'vue';
import type { AsamTreeProps, AsamTreeOptionProps, AsamTreeNodeData, AsamTreeRenderContentContext, AsamTreeFakeNode, AsamTreeData, AsamTreeLoadFunction, AsamTreeExpose, AsamTreeSelectNativeValueProps, AsamTreeKey, AsamTreeRenderContentFunction, AsamTreeAllowDragFunction, AsamTreeAllowDropFunction, AsamTreeAllowDropType, AsamTreeFilterNodeMethodFunction, AsamTreeCheckedInfo, AsamTreeNodeDropType } from '@asam-ui/ui';

type PublicMember<T, K extends PropertyKey> = T extends unknown ? K extends keyof T ? T[K] : never : never;

// AsamTreeProps
type PublicContract = {
	readonly "props"?: AsamTreeOptionProps | undefined;
	readonly "data"?: AsamTreeData | undefined;
	readonly "lazy"?: boolean | undefined;
	readonly "checkStrictly"?: boolean | undefined;
	readonly "autoExpandParent"?: (AsamTreeProps)["autoExpandParent"];
	readonly "defaultExpandAll"?: boolean | undefined;
	readonly "checkDescendants"?: boolean | undefined;
	readonly "checkOnClickNode"?: boolean | undefined;
	readonly "checkOnClickLeaf"?: (AsamTreeProps)["checkOnClickLeaf"];
	readonly "accordion"?: boolean | undefined;
	readonly "draggable"?: boolean | undefined;
	readonly "indent"?: number | undefined;
	readonly "renderAfterExpand"?: (AsamTreeProps)["renderAfterExpand"];
	readonly "showCheckbox"?: boolean | undefined;
	readonly "expandOnClickNode"?: (AsamTreeProps)["expandOnClickNode"];
	readonly "highlightCurrent"?: boolean | undefined;
	"style"?: unknown;
	readonly "emptyText"?: string | undefined;
	readonly "load"?: AsamTreeLoadFunction | undefined;
	readonly "onCurrent-change"?: ((data: any, node: AsamTreeRenderContentContext["node"] | null) => any) | undefined;
	"key"?: PropertyKey | undefined;
	"ref"?: VNodeRef | undefined;
	"ref_for"?: boolean | undefined;
	"ref_key"?: string | undefined;
	"onVnodeBeforeMount"?: (AsamTreeProps)["onVnodeBeforeMount"];
	"onVnodeMounted"?: (AsamTreeProps)["onVnodeMounted"];
	"onVnodeBeforeUpdate"?: (AsamTreeProps)["onVnodeBeforeUpdate"];
	"onVnodeUpdated"?: (AsamTreeProps)["onVnodeUpdated"];
	"onVnodeBeforeUnmount"?: (AsamTreeProps)["onVnodeBeforeUnmount"];
	"onVnodeUnmounted"?: (AsamTreeProps)["onVnodeUnmounted"];
	"class"?: unknown;
	readonly "icon"?: (AsamTreeProps)["icon"];
	readonly "nodeKey"?: string | undefined;
	readonly "defaultCheckedKeys"?: AsamTreeKey[] | undefined;
	readonly "defaultExpandedKeys"?: AsamTreeKey[] | undefined;
	readonly "currentNodeKey"?: (AsamTreeProps)["currentNodeKey"];
	readonly "renderContent"?: AsamTreeRenderContentFunction | undefined;
	readonly "allowDrag"?: AsamTreeAllowDragFunction | undefined;
	readonly "allowDrop"?: AsamTreeAllowDropFunction | undefined;
	readonly "filterNodeMethod"?: AsamTreeFilterNodeMethodFunction | undefined;
	readonly "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
	readonly "onNode-click"?: ((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null, evt: MouseEvent) => any) | undefined;
	readonly "onNode-contextmenu"?: ((evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => any) | undefined;
	readonly "onNode-collapse"?: ((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => any) | undefined;
	readonly "onNode-expand"?: ((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => any) | undefined;
	readonly "onCheck"?: ((data: any, checkedInfo: AsamTreeCheckedInfo) => any) | undefined;
	readonly "onNode-drag-start"?: ((node: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-end"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] | null, dropType: AsamTreeNodeDropType, evt: DragEvent) => any) | undefined;
	readonly "onNode-drop"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" | "after" | "inner", evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-leave"?: ((draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-enter"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-over"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
};

完整的上游实例，包含全部公开方法与响应式状态。

参数与事件说明

`$`

必填：是；声明来源：依赖声明。

$ 参数与事件数据

必填：是；声明来源：依赖声明。

`$parent`

必填：是；声明来源：依赖声明。

`$host`

必填：是；声明来源：依赖声明。

$host 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

嵌套展开边界：大型实例类型；完整类型见公开类型视图。

`$emit`

必填：是；声明来源：依赖声明。

$emit 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(event: "current-change", ...args: [data: any, node: AsamTreeRenderContentContext["node"] | null]): void

事件参数：(event: "check-change", ...args: [data: any, checked: boolean, indeterminate: boolean]): void

事件参数：(event: "node-click", ...args: [data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null, evt: MouseEvent]): void

事件参数：(event: "node-contextmenu", ...args: [evt: globalThis.Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null]): void

事件参数：(event: "node-collapse", ...args: [data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null]): void

事件参数：(event: "node-expand", ...args: [data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null]): void

事件参数：(event: "check", ...args: [data: any, checkedInfo: AsamTreeCheckedInfo]): void

事件参数：(event: "node-drag-start", ...args: [node: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

事件参数：(event: "node-drag-end", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] | null, dropType: AsamTreeNodeDropType, evt: DragEvent]): void

事件参数：(event: "node-drop", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" | "after" | "inner", evt: DragEvent]): void

事件参数：(event: "node-drag-leave", ...args: [draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

事件参数：(event: "node-drag-enter", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

事件参数：(event: "node-drag-over", ...args: [draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent]): void

嵌套展开边界：复杂类型；完整类型见公开类型视图。

`$el`

必填：是；声明来源：依赖声明。

`$options`

必填：是；声明来源：依赖声明。

$options 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

嵌套展开边界：复杂类型；完整类型见公开类型视图。

`$forceUpdate`

必填：是；声明来源：依赖声明。

$forceUpdate 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(): void

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`$nextTick`

必填：是；声明来源：依赖声明。

$nextTick 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(): Promise<void>

事件参数：<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promise<R>

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`$watch`

必填：是；声明来源：依赖声明。

$watch 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：<T extends string | ((...args: any) => any)>(source: T, cb: Parameters<Extract<NonNullable<(AsamTreeExpose)["$watch"]>, (...args: never[]) => unknown>>[1], options?: WatchOptions<boolean> | undefined): WatchStopHandle

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`props`

必填：是；声明来源：上游声明。

props 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

props.children: string | undefined — 上游声明
指定子树为节点对象的某个属性值
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
props.label: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined — 上游声明
指定节点标签为节点对象的某个属性值
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): string
props.disabled: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined — 上游声明
指定节点选择框是否禁用为节点对象的某个属性值
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): boolean
props.isLeaf: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined — 上游声明
指定节点是否为叶子节点，仅在指定了 lazy 属性的情况下生效
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): boolean
props.class: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined — 上游声明
自定义节点类名
固定上游文档默认：未声明（2.14.7；文档事实，实际默认以 ASAM 源码 / 安装包为准）
事件参数：(data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]): string | { [key: string]: boolean; }

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`defaultExpandAll`

必填：是；声明来源：上游声明。

defaultExpandAll 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

`checkDescendants`

必填：是；声明来源：上游声明。

checkDescendants 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

`checkOnClickNode`

必填：是；声明来源：上游声明。

checkOnClickNode 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

`checkOnClickLeaf`

必填：是；声明来源：上游声明。

checkOnClickLeaf 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`accordion`

必填：是；声明来源：上游声明。

accordion 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

`draggable`

必填：是；声明来源：上游声明。

draggable 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

`indent`

必填：是；声明来源：上游声明。

`renderAfterExpand`

必填：是；声明来源：上游声明。

renderAfterExpand 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`showCheckbox`

必填：是；声明来源：上游声明。

showCheckbox 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

`expandOnClickNode`

必填：是；声明来源：上游声明。

expandOnClickNode 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

枚举：false / true

嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。

`highlightCurrent`

必填：是；声明来源：上游声明。

highlightCurrent 参数与事件数据

必填：否；声明来源：上游声明。

icon 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(props: any, ctx: Parameters<Extract<NonNullable<(AsamTreeExpose)["icon"]>, (...args: never[]) => unknown>>[1]): any

icon.__isFragment: undefined — 依赖声明
icon.__isTeleport: undefined — 依赖声明
icon.__isSuspense: undefined — 依赖声明

事件参数：(node: AsamTreeRenderContentContext["node"]): boolean

`allowDrop`

必填：否；声明来源：上游声明。

allowDrop 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], type: AsamTreeAllowDropType): boolean

`filterNodeMethod`

必填：否；声明来源：上游声明。

filterNodeMethod 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(value: any, data: AsamTreeNodeData, child: AsamTreeRenderContentContext["node"]): boolean

`onCheck-change`

必填：否；声明来源：上游声明。

onCheck-change 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

事件参数：(data: any, checked: boolean, indeterminate: boolean): any

`onNode-click`

必填：否；声明来源：上游声明。

onNode-click 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

必填：是；声明来源：上游声明。

ns 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

ns.namespace: (NonNullable<(AsamTreeExpose)["ns"]>)["namespace"] — 上游声明
嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。
ns.b: (blockSuffix?: string) => string — 上游声明
事件参数：(blockSuffix?: string | undefined): string
ns.e: (element?: string) => string — 上游声明
事件参数：(element?: string | undefined): string
ns.m: (modifier?: string) => string — 上游声明
事件参数：(modifier?: string | undefined): string
ns.be: (blockSuffix?: string, element?: string) => string — 上游声明
事件参数：(blockSuffix?: string | undefined, element?: string | undefined): string
ns.em: (element?: string, modifier?: string) => string — 上游声明
事件参数：(element?: string | undefined, modifier?: string | undefined): string
ns.bm: (blockSuffix?: string, modifier?: string) => string — 上游声明
事件参数：(blockSuffix?: string | undefined, modifier?: string | undefined): string
ns.bem: (blockSuffix?: string, element?: string, modifier?: string) => string — 上游声明
事件参数：(blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined): string
ns.is: { (name: string, state: boolean | undefined): string; (name: string): string; } — 上游声明
事件参数：(name: string, state: boolean | undefined): string
事件参数：(name: string): string
ns.cssVar: (object: Record<string, string>) => Record<string, string> — 上游声明
事件参数：(object: Record<string, string>): Record<string, string>
ns.cssVarName: (name: string) => string — 上游声明
事件参数：(name: string): string
ns.cssVarBlock: (object: Record<string, string>) => Record<string, string> — 上游声明
事件参数：(object: Record<string, string>): Record<string, string>
ns.cssVarBlockName: (name: string) => string — 上游声明
事件参数：(name: string): string

`store`

必填：是；声明来源：上游声明。

store 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

嵌套展开边界：大型实例类型；完整类型见公开类型视图。

`root`

必填：是；声明来源：上游声明。

root 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

嵌套展开边界：大型实例类型；完整类型见公开类型视图。

`currentNode`

必填：是；声明来源：上游声明。

currentNode 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

嵌套展开边界：大型实例类型；完整类型见公开类型视图。

`dragState`

必填：是；声明来源：上游声明。

dragState 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

dragState.allowDrop: boolean — 上游声明
枚举：false / true
dragState.dropType: AsamTreeNodeDropType | null — 上游声明
枚举："none" / "before" / "after" / "inner"
dragState.draggingNode: 完整类型见公开类型视图 — 上游声明
- dragState.draggingNode.node: 完整类型见公开类型视图 — 上游声明
  嵌套展开边界：大型实例类型；完整类型见公开类型视图。
- dragState.draggingNode.$el: HTMLElement | undefined — 上游声明
  嵌套展开边界：大型实例类型；完整类型见公开类型视图。
嵌套展开边界：复杂类型；完整类型见公开类型视图。
dragState.showDropIndicator: boolean — 上游声明
枚举：false / true
dragState.dropNode: 完整类型见公开类型视图 — 上游声明
- dragState.dropNode.node: 完整类型见公开类型视图 — 上游声明
  嵌套展开边界：大型实例类型；完整类型见公开类型视图。
- dragState.dropNode.$el: HTMLElement | undefined — 上游声明
  嵌套展开边界：大型实例类型；完整类型见公开类型视图。
嵌套展开边界：复杂类型；完整类型见公开类型视图。

$route.matched: (NonNullable<AsamTreeExpose["$route"]>)["matched"] — 依赖声明
仅包含普通组件的 RouteLocationMatched 数组；懒加载组件已解析并替换 components 中的值，可直接展示路由，不包含重定向记录。此属性不可枚举。
嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。
$route.name: (NonNullable<AsamTreeExpose["$route"]>)["name"] — 依赖声明
匹配路由记录的名称。
$route.fullPath: string — 依赖声明
包含 search 和 hash 的完整位置字符串，使用百分号编码。
$route.query: (NonNullable<AsamTreeExpose["$route"]>)["query"] — 依赖声明
当前位置 search 属性的对象表示。
$route.hash: string — 依赖声明
当前位置的哈希片段；存在时以 # 开头。
$route.redirectedFrom: (NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"] — 依赖声明
最终到达当前位置之前，最初尝试访问的位置。
- $route.redirectedFrom.matched: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "matched"> — 依赖声明
  包含添加路由时原始组件的 RouteRecord 数组，也可能包含重定向记录，不能直接用于展示。此属性不可枚举。
  嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。
- $route.redirectedFrom.fullPath: string — 依赖声明
  包含 search 和 hash 的完整位置字符串，使用百分号编码。
- $route.redirectedFrom.query: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "query"> — 依赖声明
  当前位置 search 属性的对象表示。
- $route.redirectedFrom.hash: string — 依赖声明
  当前位置的哈希片段；存在时以 # 开头。
- $route.redirectedFrom.redirectedFrom: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "redirectedFrom"> — 依赖声明
  最终到达当前位置之前，最初尝试访问的位置。
  嵌套展开边界：递归引用；完整类型见公开类型视图。
- $route.redirectedFrom.name: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "name"> — 依赖声明
  匹配路由记录的名称。
- $route.redirectedFrom.meta: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "meta"> — 依赖声明
  全部匹配路由记录合并后的 meta 属性。
- $route.redirectedFrom.params: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "params"> — 依赖声明
  从 path 提取并解码后的参数对象。
- $route.redirectedFrom.path: string — 依赖声明
  URL 中经过百分号编码的路径部分。
- $route.redirectedFrom.replace: boolean | undefined — 依赖声明
  替换当前历史记录，而不是添加新记录。
  枚举：false / true
- $route.redirectedFrom.force: boolean | undefined — 依赖声明
  即使目标与当前位置相同，也触发导航；除非传入 replace: true，否则会添加一条历史记录。
  枚举：false / true
- $route.redirectedFrom.state: PublicMember<NonNullable<(NonNullable<AsamTreeExpose["$route"]>)["redirectedFrom"]>, "state"> — 依赖声明
  通过 History API 保存的状态；不能包含响应式值，也不允许 Symbol 等部分值。详情参见 https://developer.mozilla.org/zh-CN/docs/Web/API/History/state。
$route.meta: (NonNullable<AsamTreeExpose["$route"]>)["meta"] — 依赖声明
全部匹配路由记录合并后的 meta 属性。
$route.params: (NonNullable<AsamTreeExpose["$route"]>)["params"] — 依赖声明
从 path 提取并解码后的参数对象。
$route.path: string — 依赖声明
URL 中经过百分号编码的路径部分。

`$router`

必填：是；声明来源：依赖声明。

$router 参数与事件数据

下列为声明可读视图；可导入类型以公开类型视图为准。分支条件与父属性一致。

$router.options: (NonNullable<AsamTreeExpose["$router"]>)["options"] — 依赖声明
创建路由器时传入的原始配置对象。
- $router.options.routes: (NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["routes"] — 依赖声明
  需要添加到路由器的初始路由列表。
  嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。
- $router.options.history: (NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"] — 依赖声明
  路由器使用的历史记录实现。通常使用 createWebHistory，并配置服务器回退；createWebHashHistory 无需服务器配置，但搜索引擎无法处理其哈希路由，影响搜索优化。
  - $router.options.history.base: string — 依赖声明
    添加到每个 URL 前的基础路径；例如 base 为 /sub-folder 时，可将单页应用部署在域名的对应子目录。
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.location: string — 依赖声明
    当前历史记录位置。
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.state: (NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["state"] — 依赖声明
    当前历史记录状态。
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.push: (NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["push"] — 依赖声明
    导航到指定位置；使用 HTML5 History 时，通过 history.pushState 实际更新 URL。
    事件参数：(to: string, data?: Parameters<Extract<NonNullable<(NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["push"]>, (...args: never[]) => unknown>>[1]): void
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.replace: (NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["replace"] — 依赖声明
    与 RouterHistory.push 类似，但调用 history.replaceState，而非 history.pushState。
    事件参数：(to: string, data?: Parameters<Extract<NonNullable<(NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["replace"]>, (...args: never[]) => unknown>>[1]): void
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.go: (delta: number, triggerListeners?: boolean) => void — 依赖声明
    按指定方向遍历历史记录。
    事件参数：(delta: number, triggerListeners?: boolean | undefined): void
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.listen: (NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["listen"] — 依赖声明
    为历史记录实现添加监听器；由浏览器前进、后退等外部导航，或传入 true 的 RouterHistory.back、RouterHistory.forward 触发。
    事件参数：(callback: Parameters<Extract<NonNullable<(NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["history"]>)["listen"]>, (...args: never[]) => unknown>>[0]): () => void
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.createHref: (location: AsamTreeComponentProps["emptyText"]) => string — 依赖声明
    生成用于链接元素的对应 href。
    事件参数：(location: string): string
    嵌套展开边界：深度上限；完整类型见公开类型视图。
  - $router.options.history.destroy: () => void — 依赖声明
    清除历史记录实现注册的全部事件监听器。
    事件参数：(): void
    嵌套展开边界：深度上限；完整类型见公开类型视图。
- $router.options.scrollBehavior: (NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["scrollBehavior"] — 依赖声明
  控制页面导航时滚动行为的函数；可返回 Promise 延迟滚动。
  事件参数：(to: Parameters<Extract<NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["scrollBehavior"]>, (...args: never[]) => unknown>>[0], from: AsamTreeExpose["$route"], savedPosition: Parameters<Extract<NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["scrollBehavior"]>, (...args: never[]) => unknown>>[2]): ReturnType<Extract<NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["scrollBehavior"]>, (...args: never[]) => unknown>>
- $router.options.parseQuery: (NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["parseQuery"] — 依赖声明
  自定义查询参数解析函数；与 EXPERIMENTAL_RouterOptions_Base.stringifyQuery 配套。
  事件参数：(search: string): ReturnType<Extract<NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["parseQuery"]>, (...args: never[]) => unknown>>
- $router.options.stringifyQuery: (NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["stringifyQuery"] — 依赖声明
  自定义查询对象序列化函数；不要添加开头的 ?，与 parseQuery 的解析函数配套。
  事件参数：(query: Parameters<Extract<NonNullable<(NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["options"]>)["stringifyQuery"]>, (...args: never[]) => unknown>>[0]): string
- $router.options.linkActiveClass: string | undefined — 依赖声明
  应用于激活 RouterLink 的默认类名；未指定时使用 router-link-active。
- $router.options.linkExactActiveClass: string | undefined — 依赖声明
  应用于精确激活 RouterLink 的默认类名；未指定时使用 router-link-exact-active。
- $router.options.end: boolean | undefined — 依赖声明
  是否在表达式末尾添加 $，使其匹配到路径结尾。
  声明默认：`true`（注释，实际运行默认以源码/安装包为准）
  枚举：false / true
- $router.options.sensitive: boolean | undefined — 依赖声明
  使正则表达式区分大小写。
  声明默认：`false`（注释，实际运行默认以源码/安装包为准）
  枚举：false / true
- $router.options.strict: boolean | undefined — 依赖声明
  是否禁止路径末尾的斜杠。
  声明默认：`false`（注释，实际运行默认以源码/安装包为准）
  枚举：false / true
$router.addRoute: (NonNullable<AsamTreeExpose["$router"]>)["addRoute"] — 依赖声明
向已有路由添加子路由，或向路由器添加新的 RouteRecordRaw 路由记录。
事件参数完整签名见公开类型视图。
事件参数完整签名见公开类型视图。
$router.removeRoute: (NonNullable<AsamTreeExpose["$router"]>)["removeRoute"] — 依赖声明
按名称移除已有路由。
事件参数：(name: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["removeRoute"]>, (...args: never[]) => unknown>>[0]): void
$router.clearRoutes: () => void — 依赖声明
从路由器中删除全部路由。
事件参数：(): void
$router.currentRoute: ShallowRef<AsamTreeExpose["$route"]> — 依赖声明
当前 RouteLocationNormalized。
嵌套展开边界：框架 / 平台类型；完整类型见公开类型视图。
$router.listening: boolean — 依赖声明
允许关闭历史事件监听，这是用于微前端的底层 API。
枚举：false / true
$router.hasRoute: (NonNullable<AsamTreeExpose["$router"]>)["hasRoute"] — 依赖声明
检查指定名称的路由是否存在。
事件参数：(name: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["hasRoute"]>, (...args: never[]) => unknown>>[0]): boolean
$router.getRoutes: (NonNullable<AsamTreeExpose["$router"]>)["getRoutes"] — 依赖声明
获取全部 RouteRecord 路由记录的完整列表。
事件参数：(): ReturnType<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["getRoutes"]>, (...args: never[]) => unknown>>
$router.resolve: (NonNullable<AsamTreeExpose["$router"]>)["resolve"] — 依赖声明
返回 RouteLocationRaw 的规范化位置，包含带基础路径的 href；默认使用 router.currentRoute 作为 currentLocation，仅在高级场景中覆盖。
事件参数完整签名见公开类型视图。
事件参数完整签名见公开类型视图。
$router.push: (NonNullable<AsamTreeExpose["$router"]>)["push"] — 依赖声明
通过向历史栈添加记录，以编程方式导航到新 URL。
事件参数：(to: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["push"]>, (...args: never[]) => unknown>>[0]): ReturnType<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["push"]>, (...args: never[]) => unknown>>
$router.replace: (NonNullable<AsamTreeExpose["$router"]>)["replace"] — 依赖声明
通过替换历史栈中的当前记录，以编程方式导航到新 URL。
事件参数：(to: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["replace"]>, (...args: never[]) => unknown>>[0]): ReturnType<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["replace"]>, (...args: never[]) => unknown>>
$router.back: () => void — 依赖声明
通过 history.back() 在可用时后退，等价于 router.go(-1)。
事件参数：(): void
$router.forward: () => void — 依赖声明
通过 history.forward() 在可用时前进，等价于 router.go(1)。
事件参数：(): void
$router.go: (delta: number) => void — 依赖声明
通过调用 history.go() 在历史记录中前进或后退。
事件参数：(delta: number): void
$router.beforeEach: (NonNullable<AsamTreeExpose["$router"]>)["beforeEach"] — 依赖声明
添加每次导航之前执行的守卫，并返回移除此守卫的函数。
事件参数：(guard: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["beforeEach"]>, (...args: never[]) => unknown>>[0]): () => void
$router.beforeResolve: (NonNullable<AsamTreeExpose["$router"]>)["beforeResolve"] — 依赖声明
添加导航确认之前执行的守卫，此时组件已获取且其他导航守卫已通过；返回移除此守卫的函数。
事件参数：(guard: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["beforeResolve"]>, (...args: never[]) => unknown>>[0]): () => void
$router.afterEach: (NonNullable<AsamTreeExpose["$router"]>)["afterEach"] — 依赖声明
添加每次导航结束后执行的钩子，并返回移除此钩子的函数。
事件参数：(guard: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["afterEach"]>, (...args: never[]) => unknown>>[0]): () => void
$router.onError: (NonNullable<AsamTreeExpose["$router"]>)["onError"] — 依赖声明
添加导航期间未捕获错误的处理函数，涵盖同步和异步异常、守卫返回或传给 next 的错误，以及路由异步组件解析错误。
事件参数：(handler: Parameters<Extract<NonNullable<(NonNullable<AsamTreeExpose["$router"]>)["onError"]>, (...args: never[]) => unknown>>[0]): () => void
$router.isReady: () => Promise<void> — 依赖声明
返回在初次导航完成后兑现的 Promise，此时关联的异步进入钩子与异步组件均已解析；导航已完成时立即兑现。可用于保持服务端与客户端渲染一致；服务端需手动推入初始位置，客户端从 URL 自动读取。
事件参数：(): Promise<void>
$router.install: (app: App) => void — 依赖声明
由 app.use(router) 自动调用，用户不应手动调用；客户端调用时会触发初次导航。
事件参数：(app: App<any>): void

AsamTreeExpose 公开类型视图

import type { ComponentPublicInstance, ComponentOptionsBase, ComponentProvideOptions, ExtractPropTypes, PropType, Ref, ComponentOptionsMixin, DefineComponent, CreateComponentPublicInstanceWithMixins, GlobalComponents, GlobalDirectives, VNodeProps, AllowedComponentProps, ComponentCustomProps, ObjectPlugin, ComputedOptions, MethodOptions, WatchOptions, WatchStopHandle, VNode, Component, ShallowRef, App } from 'vue';
import type { AsamTreeExpose, AsamTableColumnExpose, AsamTreeProps, AsamAvatarGroupSlots, AsamTreeRenderContentContext, AsamTreeCheckedInfo, AsamTreeNodeDropType, AsamTreeKey, AsamTreeRenderContentFunction, AsamTreeAllowDragFunction, AsamTreeAllowDropFunction, AsamTreeLoadFunction, AsamTreeFilterNodeMethodFunction, AsamTreeNodeData, AsamTreeFakeNode, AsamTreeNodeLoadedDefaultProps, AsamTreeStoreNodesMap, AsamTreeFilterValue, AsamTreeData, AsamTreeOptionProps, AsamTreeRootTreeType, AsamTreeSelectNativeValueProps, AsamTreeAllowDropType, AsamTreeComponentProps } from '@asam-ui/ui';

type PublicMember<T, K extends PropertyKey> = T extends unknown ? K extends keyof T ? T[K] : never : never;

// AsamTreeExpose
type PublicContract = {
	"$": AsamTreeExpose["$"];
	"$data": AsamTableColumnExpose;
	"$props": AsamTreeProps;
	"$attrs": AsamTreeExpose["$attrs"];
	"$refs": AsamTreeExpose["$refs"];
	"$slots": AsamAvatarGroupSlots;
	"$root": ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> | null;
	"$parent": ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, ComponentProvideOptions>, {}, {}, "", {}, any> | null;
	"$host": Element | null;
	"$emit": ((event: "current-change", data: any, node: AsamTreeRenderContentContext["node"] | null) => void) & ((event: "check-change", data: any, checked: boolean, indeterminate: boolean) => void) & ((event: "node-click", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null, evt: MouseEvent) => void) & ((event: "node-contextmenu", evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => void) & ((event: "node-collapse", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => void) & ((event: "node-expand", data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => void) & ((event: "check", data: any, checkedInfo: AsamTreeCheckedInfo) => void) & ((event: "node-drag-start", node: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-end", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] | null, dropType: AsamTreeNodeDropType, evt: DragEvent) => void) & ((event: "node-drop", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" | "after" | "inner", evt: DragEvent) => void) & ((event: "node-drag-leave", draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-enter", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void) & ((event: "node-drag-over", draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => void);
	"$el": any;
	"$options": (AsamTreeExpose)["$options"];
	"$forceUpdate": () => void;
	"$nextTick": (AsamTreeExpose)["$nextTick"];
	"$watch": (AsamTreeExpose)["$watch"];
	readonly "props": AsamTreeOptionProps;
	readonly "data": AsamTreeData;
	readonly "lazy": boolean;
	readonly "checkStrictly": boolean;
	readonly "autoExpandParent": (AsamTreeExpose)["autoExpandParent"];
	readonly "defaultExpandAll": boolean;
	readonly "checkDescendants": boolean;
	readonly "checkOnClickNode": boolean;
	readonly "checkOnClickLeaf": (AsamTreeExpose)["checkOnClickLeaf"];
	readonly "accordion": boolean;
	readonly "draggable": boolean;
	readonly "indent": number;
	readonly "renderAfterExpand": (AsamTreeExpose)["renderAfterExpand"];
	readonly "showCheckbox": boolean;
	readonly "expandOnClickNode": (AsamTreeExpose)["expandOnClickNode"];
	readonly "highlightCurrent": boolean;
	readonly "emptyText"?: string | undefined;
	readonly "load"?: AsamTreeLoadFunction | undefined;
	readonly "onCurrent-change"?: ((data: any, node: AsamTreeRenderContentContext["node"] | null) => any) | undefined;
	readonly "icon"?: (AsamTreeExpose)["icon"];
	readonly "nodeKey"?: string | undefined;
	readonly "defaultCheckedKeys"?: AsamTreeKey[] | undefined;
	readonly "defaultExpandedKeys"?: AsamTreeKey[] | undefined;
	readonly "currentNodeKey"?: (AsamTreeExpose)["currentNodeKey"];
	readonly "renderContent"?: AsamTreeRenderContentFunction | undefined;
	readonly "allowDrag"?: AsamTreeAllowDragFunction | undefined;
	readonly "allowDrop"?: AsamTreeAllowDropFunction | undefined;
	readonly "filterNodeMethod"?: AsamTreeFilterNodeMethodFunction | undefined;
	readonly "onCheck-change"?: ((data: any, checked: boolean, indeterminate: boolean) => any) | undefined;
	readonly "onNode-click"?: ((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null, evt: MouseEvent) => any) | undefined;
	readonly "onNode-contextmenu"?: ((evt: Event, data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => any) | undefined;
	readonly "onNode-collapse"?: ((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => any) | undefined;
	readonly "onNode-expand"?: ((data: any, node: AsamTreeRenderContentContext["node"], nodeInstance: AsamTreeExpose["$"] | null) => any) | undefined;
	readonly "onCheck"?: ((data: any, checkedInfo: AsamTreeCheckedInfo) => any) | undefined;
	readonly "onNode-drag-start"?: ((node: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-end"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"] | null, dropType: AsamTreeNodeDropType, evt: DragEvent) => any) | undefined;
	readonly "onNode-drop"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], dropType: "before" | "after" | "inner", evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-leave"?: ((draggingNode: AsamTreeRenderContentContext["node"], oldDropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-enter"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	readonly "onNode-drag-over"?: ((draggingNode: AsamTreeRenderContentContext["node"], dropNode: AsamTreeRenderContentContext["node"], evt: DragEvent) => any) | undefined;
	"ns": (AsamTreeExpose)["ns"];
	"store": { currentNode: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData | AsamTreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; } | null; currentNodeKey: AsamTreeKey | null; nodesMap: AsamTreeStoreNodesMap; root: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: any; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData | AsamTreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction | undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction | undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined; disabled?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; isLeaf?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData | AsamTreeKey | AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey | AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] | null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey | null, shouldAutoExpandParent?: boolean) => void; };
	"root": { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: { currentNode: any | null; currentNodeKey: AsamTreeKey | null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction | undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction | undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined; disabled?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; isLeaf?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData | AsamTreeKey | AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey | AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] | null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey | null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData | AsamTreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; };
	"currentNode": { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: { currentNode: any | null; currentNodeKey: AsamTreeKey | null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction | undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction | undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined; disabled?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; isLeaf?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData | AsamTreeKey | AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey | AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] | null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey | null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData | AsamTreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; } | null;
	"dragState": { allowDrop: boolean; dropType: AsamTreeNodeDropType | null; draggingNode: { node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: { currentNode: any | null; currentNodeKey: AsamTreeKey | null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction | undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction | undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined; disabled?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; isLeaf?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData | AsamTreeKey | AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey | AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] | null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey | null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData | AsamTreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement | undefined; } | null; showDropIndicator: boolean; dropNode: { node: { id: number; text: string | null; checked: boolean; indeterminate: boolean; data: AsamTreeNodeData; expanded: boolean; parent: any | null; visible: boolean; isCurrent: boolean; store: { currentNode: any | null; currentNodeKey: AsamTreeKey | null; nodesMap: AsamTreeStoreNodesMap; root: any; data: AsamTreeNodeData[]; lazy: boolean; load?: AsamTreeLoadFunction | undefined; filterNodeMethod?: AsamTreeFilterNodeMethodFunction | undefined; key: AsamTreeKey; defaultCheckedKeys?: AsamTreeKey[] | undefined; checkStrictly: boolean; defaultExpandedKeys?: AsamTreeKey[] | undefined; autoExpandParent: boolean; defaultExpandAll: boolean; checkDescendants: boolean; props: { children?: string | undefined; label?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string) | undefined; disabled?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; isLeaf?: string | ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => boolean) | undefined; class?: ((data: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"]) => string | { [key: string]: boolean; }) | undefined; }; initialize: () => void; filter: (value: AsamTreeFilterValue) => void; setData: (newVal: AsamTreeData) => void; getNode: (data: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => AsamTreeRenderContentContext["node"]; insertBefore: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; insertAfter: (data: AsamTreeNodeData, refData: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; remove: (data: AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void; append: (data: AsamTreeNodeData, parentData: AsamTreeNodeData | AsamTreeKey | AsamTreeRenderContentContext["node"]) => void; _initDefaultCheckedNodes: () => void; _initDefaultCheckedNode: (node: AsamTreeRenderContentContext["node"]) => void; setDefaultCheckedKey: (newVal: AsamTreeKey[]) => void; registerNode: (node: AsamTreeRenderContentContext["node"]) => void; deregisterNode: (node: AsamTreeRenderContentContext["node"]) => void; getCheckedNodes: (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[]; getCheckedKeys: (leafOnly?: boolean) => AsamTreeKey[]; getHalfCheckedNodes: () => AsamTreeNodeData[]; getHalfCheckedKeys: () => AsamTreeKey[]; _getAllNodes: () => AsamTreeRenderContentContext["node"][]; updateChildren: (key: AsamTreeKey, data: AsamTreeData) => void; _setCheckedKeys: (key: AsamTreeKey, leafOnly: boolean | undefined, checkedKeys: { [key: string]: boolean; }) => void; setCheckedNodes: (array: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void; setCheckedKeys: (keys: AsamTreeKey[], leafOnly?: boolean) => void; setDefaultExpandedKeys: (keys: AsamTreeKey[]) => void; setChecked: (data: AsamTreeKey | AsamTreeNodeData, checked: boolean, deep: boolean) => void; getCurrentNode: () => AsamTreeRenderContentContext["node"] | null; setCurrentNode: (currentNode: AsamTreeRenderContentContext["node"]) => void; setUserCurrentNode: (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void; setCurrentNodeKey: (key: AsamTreeKey | null, shouldAutoExpandParent?: boolean) => void; }; isLeafByUser: boolean | undefined; isLeaf: boolean | undefined; canFocus: boolean; level: number; loaded: boolean; childNodes: any[]; loading: boolean; isEffectivelyChecked: boolean; initialize: () => void; setData: (data: AsamTreeNodeData) => void; readonly label: string; readonly key: AsamTreeKey | null | undefined; readonly disabled: boolean; readonly nextSibling: any | null; readonly previousSibling: any | null; contains: (target: AsamTreeRenderContentContext["node"], deep?: boolean) => boolean; remove: () => void; insertChild: (child?: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], index?: number, batch?: boolean) => void; insertBefore: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; insertAfter: (child: AsamTreeFakeNode | AsamTreeRenderContentContext["node"], ref: AsamTreeRenderContentContext["node"]) => void; removeChild: (child: AsamTreeRenderContentContext["node"]) => void; removeChildByData: (data: AsamTreeNodeData | null) => void; expand: (callback?: (() => void) | null, expandParent?: boolean) => void; doCreateChildren: (array: AsamTreeNodeData[], defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; collapse: () => void; shouldLoadData: () => boolean; updateLeafState: () => void; setChecked: (value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean) => void; getChildren: (forceInit?: boolean) => AsamTreeNodeData | AsamTreeNodeData[] | null; updateChildren: () => void; loadData: (callback: (data?: AsamTreeNodeData[]) => void, defaultProps?: AsamTreeNodeLoadedDefaultProps) => void; eachNode: (callback: (node: AsamTreeRenderContentContext["node"]) => void) => void; reInitChecked: () => void; }; $el?: HTMLElement | undefined; } | null; };
	"el$": (AsamTreeExpose)["el$"];
	"dropIndicator$": (AsamTreeExpose)["dropIndicator$"];
	"isEmpty": boolean;
	"filter": (value: AsamTreeFilterValue) => void;
	"getNodeKey": (node: AsamTreeRenderContentContext["node"]) => any;
	"getNodePath": (data: AsamTreeKey | AsamTreeNodeData) => AsamTreeNodeData[];
	"getCheckedNodes": (leafOnly?: boolean, includeHalfChecked?: boolean) => AsamTreeNodeData[];
	"getCheckedKeys": (leafOnly?: boolean) => AsamTreeKey[];
	"getCurrentNode": () => AsamTreeNodeData | null;
	"getCurrentKey": () => AsamTreeKey | null;
	"setCheckedNodes": (nodes: AsamTreeRenderContentContext["node"][], leafOnly?: boolean) => void;
	"setCheckedKeys": (keys: AsamTreeKey[], leafOnly?: boolean) => void;
	"setChecked": (data: AsamTreeKey | AsamTreeNodeData, checked: boolean, deep?: boolean) => void;
	"getHalfCheckedNodes": () => AsamTreeNodeData[];
	"getHalfCheckedKeys": () => AsamTreeKey[];
	"setCurrentNode": (node: AsamTreeRenderContentContext["node"], shouldAutoExpandParent?: boolean) => void;
	"setCurrentKey": (key?: AsamTreeKey | null, shouldAutoExpandParent?: boolean) => void;
	"t": AsamTreeExpose["t"];
	"getNode": (data: AsamTreeKey | AsamTreeNodeData) => AsamTreeRenderContentContext["node"];
	"remove": (data: AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void;
	"append": (data: AsamTreeNodeData, parentNode: AsamTreeNodeData | AsamTreeKey | AsamTreeRenderContentContext["node"]) => void;
	"insertBefore": (data: AsamTreeNodeData, refNode: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void;
	"insertAfter": (data: AsamTreeNodeData, refNode: AsamTreeKey | AsamTreeNodeData | AsamTreeRenderContentContext["node"]) => void;
	"handleNodeExpand": (nodeData: AsamTreeNodeData, node: AsamTreeRenderContentContext["node"], instance: AsamTreeExpose["$"]) => void;
	"updateKeyChildren": (key: AsamTreeKey, data: AsamTreeData) => void;
	"$route": AsamTreeExpose["$route"];
	"$router": AsamTreeExpose["$router"];
};