@gct-paas/core-web 0.1.6-dev.4 → 0.1.6-dev.40

package/es/modules/data-rules-container/src/data-rules-modal.mjs

@@ -0,0 +1,105 @@
+import data_rules_container_default from "./data-rules-container.vue.mjs";
+import { createVNode, defineComponent, provide, ref } from "vue";
+import { FIELD_TYPE, useNamespace } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/data-rules-modal.tsx
+/**
+* 字段条件规则配置模态框
+*/
+var DataRulesModal = /* @__PURE__ */ defineComponent({
+	name: "DataRulesModal",
+	props: {
+		modal: {
+			type: Object,
+			required: true
+		},
+		detail: {
+			type: Object,
+			default: () => ({
+				dataRule: "",
+				dataRuleConfig: "",
+				dataRuleEnabled: true
+			})
+		},
+		modelKey: {
+			type: String,
+			default: ""
+		},
+		excludeValueType: {
+			type: Array,
+			default: () => []
+		},
+		excludeOperatorType: {
+			type: Array,
+			default: () => []
+		},
+		filterFieldKeys: { type: Object },
+		searchType: {
+			type: Object,
+			required: true
+		}
+	},
+	setup(props) {
+		const ns = useNamespace("data-rules-modal");
+		const dataRulesRef = ref();
+		provide("isDataFilterEditor", true);
+		if (props.modal) props.modal.callback(async () => {
+			const dataRulesRes = dataRulesRef.value.getDataRulesResult();
+			dataRulesRef.value.resetData();
+			return {
+				ok: true,
+				data: [{
+					dataRule: {
+						query: dataRulesRes.query,
+						varKeys: dataRulesRes.varKeys,
+						exp: dataRulesRes.exp,
+						typeMap: dataRulesRes?.typeMap || {}
+					},
+					dataRuleConfig: dataRulesRes.treeStr,
+					dataRuleEnabled: true
+				}]
+			};
+		}, async () => {
+			dataRulesRef.value.resetData();
+			return true;
+		});
+		const list = ref([]);
+		const getConditionField = async (modelKey) => {
+			const result = await _api.apaas.fieldMeta.getListConditionField({ modelKey }) || [];
+			const filterFieldKeys = props.filterFieldKeys || [
+				FIELD_TYPE.TEXT,
+				FIELD_TYPE.LONG_TEXT,
+				FIELD_TYPE.INTEGER,
+				FIELD_TYPE.LONG,
+				FIELD_TYPE.DOUBLE,
+				FIELD_TYPE.DECIMAL,
+				FIELD_TYPE.BOOLEAN,
+				FIELD_TYPE.DATE,
+				FIELD_TYPE.DATE_TIME,
+				FIELD_TYPE.TIME,
+				FIELD_TYPE.ENUM,
+				FIELD_TYPE.ENUM_MULTI,
+				FIELD_TYPE.REF,
+				FIELD_TYPE.REF_MULTI
+			];
+			list.value = result.filter((i) => filterFieldKeys.includes(i.type)).filter((v) => v.createType === "USER_DEFINED" || v.createType === "BUILTIN");
+		};
+		async function onInit() {
+			if (props.modelKey) getConditionField(props.modelKey);
+		}
+		onInit();
+		return () => {
+			return createVNode("div", { "class": ns.b() }, [createVNode(data_rules_container_default, {
+				"ref": dataRulesRef,
+				"fieldList": list.value,
+				"detail": props.detail,
+				"searchType": props.searchType,
+				"isDesign": true,
+				"isPageDesigner": true,
+				"excludeValueType": props.excludeValueType,
+				"excludeOperatorType": props.excludeOperatorType
+			}, null)]);
+		};
+	}
+});
+//#endregion
+export { DataRulesModal };

package/es/modules/data-rules-container/src/field-role-container.vue.d.ts

@@ -0,0 +1,14 @@
+import { FieldMetaDTO } from '@gct-paas/api/apaas';
+interface Props {
+    /** 模型key */
+    dataSource?: FieldMetaDTO[];
+    detail: IObject;
+}
+declare const _default: import('vue').DefineComponent<Props, {
+    getFieldRoleResult: () => {
+        fieldPermissionEnabled: boolean;
+        selectRows: any;
+    };
+    resetData: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/es/modules/data-rules-container/src/field-role-container.vue.mjs

@@ -0,0 +1,5 @@
+import field_role_container_vue_vue_type_script_setup_true_name_field_role_container_lang_default from "./field-role-container.vue_vue_type_script_setup_true_name_field-role-container_lang.mjs";
+//#region src/modules/data-rules-container/src/field-role-container.vue
+var field_role_container_default = field_role_container_vue_vue_type_script_setup_true_name_field_role_container_lang_default;
+//#endregion
+export { field_role_container_default as default };

package/es/modules/data-rules-container/src/field-role-container.vue_vue_type_script_setup_true_name_field-role-container_lang.mjs

@@ -0,0 +1,73 @@
+import header_action_default from "./components/header-action.vue.mjs";
+import { createCommentVNode, createElementBlock, createVNode, defineComponent, openBlock, ref, resolveComponent, unref, watch } from "vue";
+import { t } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/field-role-container.vue?vue&type=script&setup=true&name=field-role-container&lang.ts
+var _hoisted_1 = { class: "field-role-container" };
+var _hoisted_2 = {
+	key: 0,
+	class: "table-wrap"
+};
+var field_role_container_vue_vue_type_script_setup_true_name_field_role_container_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "field-role-container",
+	props: {
+		dataSource: {},
+		detail: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const columns = [{
+			title: t("sys.appDesigner.field"),
+			dataIndex: "name"
+		}];
+		const props = __props;
+		const selectRows = ref();
+		const fieldPermissionEnabled = ref(false);
+		const rowSelection = ref({
+			selectedRowKeys: [],
+			onChange: handleRowChange
+		});
+		watch([() => props.detail, () => props.dataSource], () => {
+			if (props.detail) {
+				fieldPermissionEnabled.value = props.detail.fieldPermissionEnabled;
+				selectRows.value = props.dataSource?.filter((item) => props.detail.fieldPermission.includes(item.key));
+				rowSelection.value.selectedRowKeys = selectRows.value?.map((item) => item.key);
+			}
+		}, { deep: true });
+		function handleRowChange(selectedRowKeys, selectedRows) {
+			rowSelection.value.selectedRowKeys = selectedRowKeys;
+			selectRows.value = selectedRows;
+		}
+		const getFieldRoleResult = () => {
+			return {
+				fieldPermissionEnabled: fieldPermissionEnabled.value,
+				selectRows: selectRows.value?.map((item) => item.key) || []
+			};
+		};
+		const resetData = () => {
+			selectRows.value = void 0;
+			fieldPermissionEnabled.value = false;
+			rowSelection.value.selectedRowKeys = [];
+		};
+		__expose({
+			getFieldRoleResult,
+			resetData
+		});
+		return (_ctx, _cache) => {
+			const _component_a_table = resolveComponent("a-table");
+			return openBlock(), createElementBlock("div", _hoisted_1, [createVNode(header_action_default, {
+				checked: fieldPermissionEnabled.value,
+				"onUpdate:checked": _cache[0] || (_cache[0] = ($event) => fieldPermissionEnabled.value = $event),
+				title: unref(t)("sys.appDesigner.fieldList")
+			}, null, 8, ["checked", "title"]), fieldPermissionEnabled.value ? (openBlock(), createElementBlock("div", _hoisted_2, [createVNode(_component_a_table, {
+				"data-source": __props.dataSource,
+				columns,
+				"show-index-column": false,
+				pagination: false,
+				striped: false,
+				bordered: true,
+				"row-selection": rowSelection.value
+			}, null, 8, ["data-source", "row-selection"])])) : createCommentVNode("", true)]);
+		};
+	}
+});
+//#endregion
+export { field_role_container_vue_vue_type_script_setup_true_name_field_role_container_lang_default as default };

package/es/modules/data-rules-container/src/hooks/useDataRulesTree.d.ts

@@ -0,0 +1,30 @@
+export declare function useDataRulesTree(isReadyOnly: boolean): {
+    setTree: (data: string) => void;
+    showDataRulesTree: import('vue').Ref<IObject[], IObject[]>;
+    editDataRulesTree: import('vue').Ref<IObject[], IObject[]>;
+    addNewGroup: (id: string) => void;
+    addNewRow: (pid: string, id?: string) => void;
+    deleteGroup: (id: string) => void;
+    deleteRow: (id: string) => void;
+    updateNodeItem: (id: string, attr: string, value: IObject | string | string[] | number | null | undefined, opts?: IObject) => void;
+    getDataRules: (type: string, mainModelKey: string) => {
+        exp?: undefined;
+        error: never;
+        query?: undefined;
+        varKeys?: undefined;
+        treeStr?: undefined;
+        typeMap?: undefined;
+    } | {
+        error?: undefined;
+        query: {};
+        varKeys: string[];
+        exp: string;
+        treeStr: string;
+        typeMap: {};
+    };
+    resetTree: () => void;
+    getAllExpandedKeys: () => {
+        allExpandedKeys: any[];
+        selectFiledKeys: any[];
+    };
+};

package/es/modules/data-rules-container/src/hooks/useDataRulesTree.mjs

@@ -0,0 +1,317 @@
+import { OperatorTypeEnum } from "../constant/interface.mjs";
+import { reactive, ref, toRaw } from "vue";
+import { isEmpty } from "lodash-es";
+import { FIELD_TYPE, SEARCH_SERVICE, t, useUUid } from "@gct-paas/core";
+//#region src/modules/data-rules-container/src/hooks/useDataRulesTree.ts
+var editDataRulesTree = ref([]);
+var showDataRulesTree = ref([]);
+function useDataRulesTree(isReadyOnly) {
+	const { getUuidGenerate } = useUUid(ref([]), ref(""), {
+		needPrefix: true,
+		isString: false,
+		prefix: "t_"
+	});
+	const uuidGenerate = getUuidGenerate([]);
+	const transfromReactive = (data) => {
+		return data.map((item) => {
+			const node = reactive(Object.assign({}, {
+				key: item.key,
+				pid: item.pid,
+				level: item.level,
+				class: item.class
+			}, item.type === "group" ? {
+				operatorType: item.operatorType,
+				type: item.type,
+				children: reactive([])
+			} : {
+				firstRow: item.firstRow,
+				leftValue: item.leftValue,
+				operatorValue: item.operatorValue,
+				rightValue: item.rightValue
+			}));
+			if (Array.isArray(item.children)) node.children?.push(...transfromReactive(item.children));
+			return node;
+		});
+	};
+	const setPageTreeItem = (data, len) => {
+		return data.forEach((item, index) => {
+			if (Array.isArray(item.children)) {
+				item.type = "group";
+				item.class = "tree-group";
+				if (isEmpty(item.operatorType)) item.operatorType = OperatorTypeEnum.AND;
+				setPageTreeItem(item.children, item.children.length);
+			} else {
+				const filterData = data.filter((item) => !item.children);
+				if (index === 0 || index === filterData.length - 1) {
+					item.class = `${index === 0 ? "first-node" : ""} ${index === filterData.length - 1 ? "last-node" : ""}`;
+					item.firstRow = index === 0;
+				} else item.class = "";
+				item.dataLen = len;
+			}
+		});
+	};
+	const addNode = ({ pid, insertId, data, isGroup = false, prevId = "" }) => {
+		if (pid === "init") {
+			const node = {
+				key: "root",
+				pid: "",
+				level: 1,
+				class: void 0,
+				operatorType: void 0,
+				type: void 0,
+				children: reactive([])
+			};
+			data.push(node);
+			return;
+		}
+		return data.forEach((item) => {
+			if (item.key === pid) {
+				const childrenNode = reactive(Object.assign({}, {
+					key: insertId,
+					pid: item.key,
+					level: Number(item.level) + 1,
+					class: ""
+				}, isGroup ? {
+					operatorType: void 0,
+					type: void 0,
+					children: reactive([])
+				} : {
+					firstRow: void 0,
+					leftValue: void 0,
+					operatorValue: void 0,
+					rightValue: void 0
+				}));
+				if (prevId) {
+					const index = item.children.findIndex((k) => k.key === prevId);
+					item.children.splice(index + 1, 0, childrenNode);
+				} else item.children.push(childrenNode);
+				item.children.forEach((i) => {
+					i.dataLen = item.children?.length;
+				});
+				return;
+			}
+			if (item.children) addNode({
+				pid,
+				insertId,
+				data: item.children,
+				isGroup,
+				prevId
+			});
+		});
+	};
+	const deleteNode = (id, data) => {
+		return data.forEach((item, index) => {
+			if (item.key === id) {
+				data.splice(index, 1);
+				return;
+			} else if (item.children) deleteNode(id, item.children);
+		});
+	};
+	const createGroupNodes = (data, pid, isInit = false) => {
+		const uuid = uuidGenerate.next();
+		addNode({
+			pid: isInit ? "init" : pid,
+			insertId: uuid,
+			data,
+			isGroup: true
+		});
+		addNode({
+			pid: isInit ? pid : uuid,
+			insertId: isInit ? uuid : uuidGenerate.next(),
+			data
+		});
+		setPageTreeItem(data);
+	};
+	const setTree = (data) => {
+		if (!data) createGroupNodes(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value, "root", true);
+		else {
+			console.log("转换成页面想要的tree结构", JSON.parse(data));
+			if (isReadyOnly) showDataRulesTree.value = transfromReactive(JSON.parse(data));
+			else editDataRulesTree.value = transfromReactive(JSON.parse(data));
+		}
+	};
+	const addNewGroup = (id) => {
+		createGroupNodes(editDataRulesTree.value, id);
+	};
+	const deleteGroup = (id) => {
+		deleteNode(id, editDataRulesTree.value);
+		setPageTreeItem(editDataRulesTree.value);
+	};
+	const addNewRow = (pid, id) => {
+		addNode({
+			pid,
+			insertId: uuidGenerate.next(),
+			data: editDataRulesTree.value,
+			isGroup: false,
+			prevId: id
+		});
+		setPageTreeItem(editDataRulesTree.value);
+	};
+	const deleteRow = (id) => {
+		deleteNode(id, editDataRulesTree.value);
+		setPageTreeItem(editDataRulesTree.value);
+	};
+	/** 递归查找是否存在树结构中的值 */
+	const findTreePathById = (leafId, nodes) => {
+		for (let i = 0; i < nodes.length; i++) {
+			if (leafId === nodes[i].key) return nodes[i];
+			if (nodes[i].children) {
+				const findResult = findTreePathById(leafId, nodes[i].children);
+				if (findResult) return findResult;
+			}
+		}
+		return null;
+	};
+	const updateNodeItem = (id, attr, value, opts) => {
+		const node = findTreePathById(id, editDataRulesTree.value);
+		if (!node) return;
+		if (attr === "rightValue") {
+			if (opts?.isRest) node.rightValue = reactive(opts.defaultValues.map((val) => {
+				return { [opts.key]: val };
+			}));
+			if (opts?.key === "valueType") node[attr][opts.index] = {};
+			node[attr][opts?.index][opts?.key] = value;
+		} else node[attr] = typeof value === "object" ? reactive(value) : value;
+		if (attr === "leftValue") {
+			/** 运算符 */
+			node.operatorValue = void 0;
+			/** 右值 */
+			node.rightValue = void 0;
+		} else if (attr === "operatorValue") node.rightValue = reactive(opts?.defaultValues?.map((val) => {
+			return { [opts.key]: val };
+		}));
+	};
+	const getAllExpandedKeys = () => {
+		const list = flatten(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value, "");
+		return {
+			allExpandedKeys: list.map((item) => item.key),
+			selectFiledKeys: list.map((item) => item.leftValue?.id).filter((i) => i)
+		};
+	};
+	const flatten = (array = [], pathStr) => {
+		return [].concat(...array.map((item) => {
+			item.pathStr = `${pathStr}|${item.children ? item.operatorType : "content"}`;
+			return [].concat({
+				key: item.key,
+				pid: item.pid,
+				operatorType: item.children ? item.operatorType : "content",
+				pathStr: item.pathStr,
+				leftValue: item.leftValue,
+				operatorValue: item.operatorValue,
+				rightValue: item.rightValue
+			}, flatten(item.children || [], item.pathStr));
+		}));
+	};
+	const getExpList = (array = [], parent, type) => {
+		return [].concat(...array.map((item) => {
+			let name = "";
+			if (!item.children && item.leftValue && item.leftValue.key && item.operatorValue && item.key) {
+				name = `${item.leftValue.field_search_key || item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				if (type === "filterConfig") name = `${item.leftValue.modelKey}#${item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				else if (type === "businessFlow") name = `${item.leftValue.nodeKey}.${item.leftValue.modelKey}.${item.operatorValue}:${item.key}`;
+			}
+			return [].concat(item.children ? [] : item.leftValue && item.leftValue.key && item.operatorValue && item.key ? {
+				name,
+				type: parent.operatorType,
+				operatorType: item.children ? item.operatorType : "content"
+			} : [], [getExpList(item.children || [], item, type)]);
+		}));
+	};
+	const filterExpList = (array) => {
+		const list = [];
+		array.forEach((item) => {
+			if (Array.isArray(item) && item.length !== 0) list.push(filterExpList(item));
+			else if (!Array.isArray(item) && item.operatorType === "content") list.push(item);
+		});
+		return list;
+	};
+	const setExpValue = (array) => {
+		const list = [];
+		array.forEach((item, index) => {
+			if (index === 0) list.push(`#before${item.type}#`);
+			if (Array.isArray(item) && item.length !== 0) list.push(...setExpValue(item));
+			else if (!Array.isArray(item)) list.push(item.name);
+			if (index === array.length - 1) list.push("#after#");
+		});
+		return list;
+	};
+	/** 递归得到数据规则算子 */
+	const getDataRules = (type, mainModelKey) => {
+		const list = flatten(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value, "");
+		let error;
+		const query = {};
+		const varKeys = [];
+		const typeMap = {};
+		list.forEach((item) => {
+			if (item.operatorType === "content") {
+				if (isEmpty(item.leftValue) || isEmpty(item.operatorValue) || isEmpty(item.rightValue)) {
+					error = t("sys.webRender.saveTip");
+					return;
+				}
+				let key = "";
+				if (type === "businessFlow") key = `${item.leftValue.nodeKey}.${item.leftValue.modelKey}.${item.operatorValue}:${item.key}`;
+				else if (type === "filterConfig") key = `${item.leftValue.modelKey}#${item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				else key = `${item.leftValue.field_search_key || item.leftValue.key}.${item.operatorValue}:${item.key}`;
+				if ([SEARCH_SERVICE.ISNOTNULL, SEARCH_SERVICE.ISNULL].includes(item.operatorValue)) Object.assign(query, { [key]: null });
+				else {
+					if (item.rightValue.some((rv) => isEmpty(rv.result))) {
+						error = t("sys.webRender.saveTip");
+						return;
+					}
+					const types = [];
+					const values = item.rightValue.map((kk) => {
+						types.push(kk.valueType);
+						if (kk.valueType === "SYS") varKeys.push(key);
+						if ([
+							FIELD_TYPE.USER_MULTI,
+							FIELD_TYPE.ORG_MULTI,
+							FIELD_TYPE.USER,
+							FIELD_TYPE.ORG
+						].includes(item.leftValue.type) && kk.valueType === "FIXED") {
+							const _orgs = kk?.result?.orgs?.map((org) => `ORG:${org}`) ?? [];
+							const _users = kk?.result?.users?.map((user) => `USER:${user}`) ?? [];
+							if ([FIELD_TYPE.USER, FIELD_TYPE.ORG].includes(item.leftValue.type) && [SEARCH_SERVICE.EQ, SEARCH_SERVICE.NE].includes(item.operatorValue)) return [..._orgs, ..._users]?.[0];
+							return [..._orgs, ..._users];
+						}
+						return kk?.valueType === "FIELD" ? mainModelKey ? `__F__:${mainModelKey}.${kk?.result}` : `__F__:${kk?.result.replace("$", ".")}` : kk?.result;
+					});
+					Object.assign(typeMap, { [key]: types.length === 1 ? toRaw(types[0]) : toRaw(types) });
+					Object.assign(query, { [key]: values.length === 1 ? toRaw(values[0]) : toRaw(values) });
+				}
+			}
+		});
+		if (error) return { error };
+		const explist = setExpValue(filterExpList(getExpList((isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value)[0].children, (isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value)[0], type)));
+		const expStr = explist.toString().replace(/#beforeAND#,/g, "AND(").replace(/#beforeOR#,/g, "OR(").replace(/,#after#/g, ")");
+		console.warn("getDataRules query", query);
+		console.warn("getDataRules varKeys", varKeys);
+		console.warn("getDataRules explist", explist);
+		console.warn("getDataRules expStr", expStr);
+		return {
+			query,
+			varKeys,
+			exp: expStr,
+			treeStr: JSON.stringify(isReadyOnly ? showDataRulesTree.value : editDataRulesTree.value),
+			typeMap
+		};
+	};
+	const resetTree = () => {
+		if (isReadyOnly) showDataRulesTree.value = [];
+		else editDataRulesTree.value = [];
+	};
+	return {
+		setTree,
+		showDataRulesTree,
+		editDataRulesTree,
+		addNewGroup,
+		addNewRow,
+		deleteGroup,
+		deleteRow,
+		updateNodeItem,
+		getDataRules,
+		resetTree,
+		getAllExpandedKeys
+	};
+}
+//#endregion
+export { useDataRulesTree };

package/es/modules/data-rules-container/src/hooks/useEmitter.d.ts

@@ -0,0 +1,10 @@
+export declare enum EmitterEnum {
+    /** 打开编辑用户组弹框 */
+    on_edit_user_group = "on-edit-user-group",
+    on_refresh_detail = "on-refresh-detail",
+    on_delete_user_group = "on-delete-user-group"
+}
+export declare function useEmitter(): {
+    emitter: import('mitt').Emitter<Record<import('mitt').EventType, unknown>>;
+    EmitterEnum: typeof EmitterEnum;
+};

package/es/modules/data-rules-container/src/hooks/useRdoHooks.d.ts

@@ -0,0 +1,37 @@
+export declare function useAsyncOptions({ bindModelKey, modelCategory }: IObject): {
+    getChildrens: (ids?: string[]) => Promise<void>;
+    getAsyncOptions: (arg: IObject) => Promise<void>;
+    treeData: import('vue').Ref<({
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+    } | {
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        value?: import('ant-design-vue/lib/vc-tree-select/TreeSelect').RawValueType | undefined;
+        title?: any;
+        label?: any;
+        key?: import('ant-design-vue/lib/vc-tree-select/interface').Key | undefined;
+        children?: /*elided*/ any[] | undefined;
+    })[] | undefined, (import('ant-design-vue/lib/vc-tree-select/TreeSelect').BaseOptionType | import('ant-design-vue/lib/vc-tree-select/TreeSelect').DefaultOptionType)[] | ({
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        children?: /*elided*/ any[] | undefined;
+    } | {
+        [x: string]: any;
+        disabled?: boolean | undefined;
+        checkable?: boolean | undefined;
+        disableCheckbox?: boolean | undefined;
+        value?: import('ant-design-vue/lib/vc-tree-select/TreeSelect').RawValueType | undefined;
+        title?: any;
+        label?: any;
+        key?: import('ant-design-vue/lib/vc-tree-select/interface').Key | undefined;
+        children?: /*elided*/ any[] | undefined;
+    })[] | undefined>;
+};