@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/concepts/Namespace__.ts

@@ -1,12 +1,12 @@
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
+import { v4 as uuidv4 } from 'uuid';
 import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Process from './Process__';
@@ -25,2472 +25,2585 @@ import ProcessComponent from './ProcessComponent__';
  */
 @concept('命名空间')
 export class Namespace extends BaseNode {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'Namespace' = 'Namespace';
-
-    /**
-     * 表示是从实体还是流程等概念产生的
-     */
-    @property()
-    originConcept: string = undefined;
-
-    /**
-     * 命名空间名称
-     */
-    @property()
-    name: string = undefined;
-
-    /**
-     * 命名空间标题
-     */
-    @property()
-    title: string = undefined;
-
-    /**
-     * 命名空间描述
-     */
-    @property()
-    description: string = undefined;
-
-    /**
-     * 命名空间列表
-     */
-    @property('Namespace')
-    children: Array<Namespace> = [];
-
-    /**
-     * 流程列表
-     */
-    @property('Process')
-    processes: Array<Process> = [];
-
-    /**
-     * 数据结构列表
-     */
-    @property('Structure')
-    structures: Array<Structure> = [];
-
-    /**
-     * 枚举列表
-     */
-    @property('Enum')
-    enums: Array<Enum> = [];
-
-    /**
-     * 逻辑列表
-     */
-    @property('Logic')
-    logics: Array<Logic> = [];
-
-    /**
-     * 函数列表
-     */
-    @property('Function')
-    functions: Array<Function> = [];
-
-    /**
-     * 接口列表
-     */
-    @property('Interface')
-    interfaces: Array<Interface> = [];
-
-    /**
-     * 页面列表
-     */
-    @property('View')
-    views: Array<View> = [];
-
-    /**
-     * 变量列表
-     */
-    @property('Variable')
-    frontendVariables: Array<Variable> = [];
-
-    /**
-     * 变量列表
-     */
-    @property('Variable')
-    variables: Array<Variable> = [];
-
-    /**
-     * 页面组件列表
-     */
-    @property('ViewComponent')
-    viewComponents: Array<ViewComponent> = [];
-
-    /**
-     * 流程组件列表
-     */
-    @property('ProcessComponent')
-    processComponents: Array<ProcessComponent> = [];
-
-    
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<Namespace>) {
-        source = Object.assign({}, Namespace.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
-    getClassName() {
-        return 'Namespace';
-    }
-
-    static from(source: any, parentNode?: any, parentKey?: string): Namespace {
-        return super.from(source, parentNode, parentKey) as Namespace;
-    }
-
-    /**
-     * 从父级删除该节点
-     * @internal
-     */
-    _delete() {
-        let params: Params = null;
-        if (this.parentNode) {
-            params = (this.parentNode as any)?.__removeNamespace?.(this);
-        }
-        return params;
-    }
-    
-
-        getNamespaceExistingNames(excludedList: Array<Namespace> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.children as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getNamespaceUniqueName(name = 'namespace1') {
-        return utils.unique(name, this.getNamespaceExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入命名空间
-    * @internal
-    * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-    */
-    _insertNamespaceAt(name: string, index: number): Namespace;
-
-    /**
-    * 插入命名空间
-    * @internal
-    * @param namespaceOptions 命名空间参数
-    */
-    _insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
-
-    /**
-    * 插入命名空间
-    * @internal
-    * @param namespace 已有的命名空间实例
-    */
-    _insertNamespaceAt(namespace: Namespace, index: number): Namespace;
-
-    _insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
-        const namespaceOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'children' };
-        let namespace: Namespace;
-        if (!options) {
-            namespace = Namespace.from({
-                ...namespaceOptions,
-                name: this.getNamespaceUniqueName(),
-            }, this, 'children');
-        } else if (typeof options === 'string') {
-            namespace = Namespace.from({
-                ...namespaceOptions,
-                name: options,
-            }, this, 'children');
-        } else if (options instanceof Namespace) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            namespace = options;
-            Object.assign(namespace, relationOptions);
-        } else {
-            namespace = Namespace.from({
-                ...namespaceOptions,
-                ...options,
-            }, this, 'children');
-        }
-        this.children.splice(index, 0, namespace);
-        return namespace;
-    }
-
-    /**
-     * 插入命名空间
-     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-     */
-    insertNamespaceAt(name: string, index: number): Namespace;
-
-    /**
-     * 插入命名空间
-     * @param namespaceOptions 命名空间参数
-     */
-    insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
-
-    /**
-     * 插入命名空间
-     * @param namespace 已有的命名空间实例
-     */
-    insertNamespaceAt(namespace: Namespace, index: number): Namespace;
-
-    insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
-        const node = this._insertNamespaceAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'children',
-        });
-        return node;
-    }
-
-    /**
-     * 添加命名空间
-     * @internal
-     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-     */
-    _addNamespace(name?: string): Namespace;
-
-    /**
-     * 添加命名空间
-     * @internal
-     * @param namespaceOptions 命名空间参数
-     */
-    _addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
-
-    /**
-     * 添加命名空间
-     * @internal
-     * @param namespace 已有的命名空间实例
-     */
-    _addNamespace(namespace: Namespace): Namespace;
-
-    _addNamespace(options?: string | Partial<Namespace> | Namespace) {
-        const index = this.children.length;
-        return this._insertNamespaceAt(options as any, index);
-    }
-
-    /**
-     * 添加命名空间
-     * @internal
-     * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-     */
-    addNamespace(name?: string): Namespace;
-
-    /**
-     * 添加命名空间
-     * @param namespaceOptions 命名空间参数
-     */
-    addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
-
-    /**
-     * 添加命名空间
-     * @param namespace 已有的命名空间实例
-     */
-    addNamespace(namespace: Namespace): Namespace;
-
-    addNamespace(options?: string | Partial<Namespace> | Namespace) {
-        const node = this._addNamespace(options as any);
-        const index = this.children.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'children',
-        });
-        return node;
-    }
-
-
-    getProcessExistingNames(excludedList: Array<Process> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.processes as Process[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getProcessUniqueName(name = 'Process1') {
-        return utils.unique(name, this.getProcessExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入流程
-    * @internal
-    * @param name 流程名称，如果不填会自动生成一个唯一名称
-    */
-    _insertProcessAt(name: string, index: number): Process;
-
-    /**
-    * 插入流程
-    * @internal
-    * @param processOptions 流程参数
-    */
-    _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
-
-    /**
-    * 插入流程
-    * @internal
-    * @param process 已有的流程实例
-    */
-    _insertProcessAt(process: Process, index: number): Process;
-
-    _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
-        const processOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'processes' };
-        let process: Process;
-        if (!options) {
-            process = Process.from({
-                ...processOptions,
-                name: this.getProcessUniqueName(),
-            }, this, 'processes');
-        } else if (typeof options === 'string') {
-            process = Process.from({
-                ...processOptions,
-                name: options,
-            }, this, 'processes');
-        } else if (options instanceof Process) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            process = options;
-            Object.assign(process, relationOptions);
-        } else {
-            process = Process.from({
-                ...processOptions,
-                ...options,
-            }, this, 'processes');
-        }
-        this.processes.splice(index, 0, process);
-        return process;
-    }
-
-    /**
-     * 插入流程
-     * @param name 流程名称，如果不填会自动生成一个唯一名称
-     */
-    insertProcessAt(name: string, index: number): Process;
-
-    /**
-     * 插入流程
-     * @param processOptions 流程参数
-     */
-    insertProcessAt(processOptions: Partial<Process>, index: number): Process;
-
-    /**
-     * 插入流程
-     * @param process 已有的流程实例
-     */
-    insertProcessAt(process: Process, index: number): Process;
-
-    insertProcessAt(options: string | Partial<Process> | Process, index: number) {
-        const node = this._insertProcessAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'processes',
-        });
-        return node;
-    }
-
-    /**
-     * 添加流程
-     * @internal
-     * @param name 流程名称，如果不填会自动生成一个唯一名称
-     */
-    _addProcess(name?: string): Process;
-
-    /**
-     * 添加流程
-     * @internal
-     * @param processOptions 流程参数
-     */
-    _addProcess(processOptions: Partial<Process>): Process;
-
-    /**
-     * 添加流程
-     * @internal
-     * @param process 已有的流程实例
-     */
-    _addProcess(process: Process): Process;
-
-    _addProcess(options?: string | Partial<Process> | Process) {
-        const index = 0;
-        return this._insertProcessAt(options as any, index);
-    }
-
-    /**
-     * 添加流程
-     * @internal
-     * @param name 流程名称，如果不填会自动生成一个唯一名称
-     */
-    addProcess(name?: string): Process;
-
-    /**
-     * 添加流程
-     * @param processOptions 流程参数
-     */
-    addProcess(processOptions: Partial<Process>): Process;
-
-    /**
-     * 添加流程
-     * @param process 已有的流程实例
-     */
-    addProcess(process: Process): Process;
-
-    addProcess(options?: string | Partial<Process> | Process) {
-        const node = this._addProcess(options as any);
-        const index = this.processes.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'processes',
-        });
-        return node;
-    }
-
-
-    getStructureExistingNames(excludedList: Array<Structure> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getStructureUniqueName(name = 'Structure1') {
-        return utils.unique(name, this.getStructureExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入数据结构
-    * @internal
-    * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-    */
-    _insertStructureAt(name: string, index: number): Structure;
-
-    /**
-    * 插入数据结构
-    * @internal
-    * @param structureOptions 数据结构参数
-    */
-    _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
-
-    /**
-    * 插入数据结构
-    * @internal
-    * @param structure 已有的数据结构实例
-    */
-    _insertStructureAt(structure: Structure, index: number): Structure;
-
-    _insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
-        const structureOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'structures' };
-        let structure: Structure;
-        if (!options) {
-            structure = Structure.from({
-                ...structureOptions,
-                name: this.getStructureUniqueName(),
-            }, this, 'structures');
-        } else if (typeof options === 'string') {
-            structure = Structure.from({
-                ...structureOptions,
-                name: options,
-            }, this, 'structures');
-        } else if (options instanceof Structure) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            structure = options;
-            Object.assign(structure, relationOptions);
-        } else {
-            structure = Structure.from({
-                ...structureOptions,
-                ...options,
-            }, this, 'structures');
-        }
-        this.structures.splice(index, 0, structure);
-        return structure;
-    }
-
-    /**
-     * 插入数据结构
-     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-     */
-    insertStructureAt(name: string, index: number): Structure;
-
-    /**
-     * 插入数据结构
-     * @param structureOptions 数据结构参数
-     */
-    insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
-
-    /**
-     * 插入数据结构
-     * @param structure 已有的数据结构实例
-     */
-    insertStructureAt(structure: Structure, index: number): Structure;
-
-    insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
-        const node = this._insertStructureAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'structures',
-        });
-        return node;
-    }
-
-    /**
-     * 添加数据结构
-     * @internal
-     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-     */
-    _addStructure(name?: string): Structure;
-
-    /**
-     * 添加数据结构
-     * @internal
-     * @param structureOptions 数据结构参数
-     */
-    _addStructure(structureOptions: Partial<Structure>): Structure;
-
-    /**
-     * 添加数据结构
-     * @internal
-     * @param structure 已有的数据结构实例
-     */
-    _addStructure(structure: Structure): Structure;
-
-    _addStructure(options?: string | Partial<Structure> | Structure) {
-        const index = 0;
-        return this._insertStructureAt(options as any, index);
-    }
-
-    /**
-     * 添加数据结构
-     * @internal
-     * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-     */
-    addStructure(name?: string): Structure;
-
-    /**
-     * 添加数据结构
-     * @param structureOptions 数据结构参数
-     */
-    addStructure(structureOptions: Partial<Structure>): Structure;
-
-    /**
-     * 添加数据结构
-     * @param structure 已有的数据结构实例
-     */
-    addStructure(structure: Structure): Structure;
-
-    addStructure(options?: string | Partial<Structure> | Structure) {
-        const node = this._addStructure(options as any);
-        const index = this.structures.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'structures',
-        });
-        return node;
-    }
-
-
-    getEnumExistingNames(excludedList: Array<Enum> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.enums as Enum[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getEnumUniqueName(name = 'Enum1') {
-        return utils.unique(name, this.getEnumExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入枚举
-    * @internal
-    * @param name 枚举名称，如果不填会自动生成一个唯一名称
-    */
-    _insertEnumAt(name: string, index: number): Enum;
-
-    /**
-    * 插入枚举
-    * @internal
-    * @param enumerationOptions 枚举参数
-    */
-    _insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
-
-    /**
-    * 插入枚举
-    * @internal
-    * @param enumeration 已有的枚举实例
-    */
-    _insertEnumAt(enumeration: Enum, index: number): Enum;
-
-    _insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
-        const enumerationOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'enums' };
-        let enumeration: Enum;
-        if (!options) {
-            enumeration = Enum.from({
-                ...enumerationOptions,
-                name: this.getEnumUniqueName(),
-            }, this, 'enums');
-        } else if (typeof options === 'string') {
-            enumeration = Enum.from({
-                ...enumerationOptions,
-                name: options,
-            }, this, 'enums');
-        } else if (options instanceof Enum) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            enumeration = options;
-            Object.assign(enumeration, relationOptions);
-        } else {
-            enumeration = Enum.from({
-                ...enumerationOptions,
-                ...options,
-            }, this, 'enums');
-        }
-        this.enums.splice(index, 0, enumeration);
-        return enumeration;
-    }
-
-    /**
-     * 插入枚举
-     * @param name 枚举名称，如果不填会自动生成一个唯一名称
-     */
-    insertEnumAt(name: string, index: number): Enum;
-
-    /**
-     * 插入枚举
-     * @param enumerationOptions 枚举参数
-     */
-    insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
-
-    /**
-     * 插入枚举
-     * @param enumeration 已有的枚举实例
-     */
-    insertEnumAt(enumeration: Enum, index: number): Enum;
-
-    insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
-        const node = this._insertEnumAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'enums',
-        });
-        return node;
-    }
-
-    /**
-     * 添加枚举
-     * @internal
-     * @param name 枚举名称，如果不填会自动生成一个唯一名称
-     */
-    _addEnum(name?: string): Enum;
-
-    /**
-     * 添加枚举
-     * @internal
-     * @param enumerationOptions 枚举参数
-     */
-    _addEnum(enumerationOptions: Partial<Enum>): Enum;
-
-    /**
-     * 添加枚举
-     * @internal
-     * @param enumeration 已有的枚举实例
-     */
-    _addEnum(enumeration: Enum): Enum;
-
-    _addEnum(options?: string | Partial<Enum> | Enum) {
-        const index = 0;
-        return this._insertEnumAt(options as any, index);
-    }
-
-    /**
-     * 添加枚举
-     * @internal
-     * @param name 枚举名称，如果不填会自动生成一个唯一名称
-     */
-    addEnum(name?: string): Enum;
-
-    /**
-     * 添加枚举
-     * @param enumerationOptions 枚举参数
-     */
-    addEnum(enumerationOptions: Partial<Enum>): Enum;
-
-    /**
-     * 添加枚举
-     * @param enumeration 已有的枚举实例
-     */
-    addEnum(enumeration: Enum): Enum;
-
-    addEnum(options?: string | Partial<Enum> | Enum) {
-        const node = this._addEnum(options as any);
-        const index = this.enums.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'enums',
-        });
-        return node;
-    }
-
-
-    getLogicExistingNames(excludedList: Array<Logic> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getLogicUniqueName(name = 'logic1') {
-        return utils.unique(name, this.getLogicExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入逻辑
-    * @internal
-    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-    */
-    _insertLogicAt(name: string, index: number): Logic;
-
-    /**
-    * 插入逻辑
-    * @internal
-    * @param logicOptions 逻辑参数
-    */
-    _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
-
-    /**
-    * 插入逻辑
-    * @internal
-    * @param logic 已有的逻辑实例
-    */
-    _insertLogicAt(logic: Logic, index: number): Logic;
-
-    _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
-        const logicOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'logics' };
-        let logic: Logic;
-        if (!options) {
-            logic = Logic.from({
-                ...logicOptions,
-                name: this.getLogicUniqueName(),
-            }, this, 'logics');
-        } else if (typeof options === 'string') {
-            logic = Logic.from({
-                ...logicOptions,
-                name: options,
-            }, this, 'logics');
-        } else if (options instanceof Logic) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            logic = options;
-            Object.assign(logic, relationOptions);
-        } else {
-            logic = Logic.from({
-                ...logicOptions,
-                ...options,
-            }, this, 'logics');
-        }
-        this.logics.splice(index, 0, logic);
-        return logic;
-    }
-
-    /**
-     * 插入逻辑
-     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-     */
-    insertLogicAt(name: string, index: number): Logic;
-
-    /**
-     * 插入逻辑
-     * @param logicOptions 逻辑参数
-     */
-    insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
-
-    /**
-     * 插入逻辑
-     * @param logic 已有的逻辑实例
-     */
-    insertLogicAt(logic: Logic, index: number): Logic;
-
-    insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
-        const node = this._insertLogicAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'logics',
-        });
-        return node;
-    }
-
-    /**
-     * 添加逻辑
-     * @internal
-     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-     */
-    _addLogic(name?: string): Logic;
-
-    /**
-     * 添加逻辑
-     * @internal
-     * @param logicOptions 逻辑参数
-     */
-    _addLogic(logicOptions: Partial<Logic>): Logic;
-
-    /**
-     * 添加逻辑
-     * @internal
-     * @param logic 已有的逻辑实例
-     */
-    _addLogic(logic: Logic): Logic;
-
-    _addLogic(options?: string | Partial<Logic> | Logic) {
-        const index = 0;
-        return this._insertLogicAt(options as any, index);
-    }
-
-    /**
-     * 添加逻辑
-     * @internal
-     * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-     */
-    addLogic(name?: string): Logic;
-
-    /**
-     * 添加逻辑
-     * @param logicOptions 逻辑参数
-     */
-    addLogic(logicOptions: Partial<Logic>): Logic;
-
-    /**
-     * 添加逻辑
-     * @param logic 已有的逻辑实例
-     */
-    addLogic(logic: Logic): Logic;
-
-    addLogic(options?: string | Partial<Logic> | Logic) {
-        const node = this._addLogic(options as any);
-        const index = this.logics.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'logics',
-        });
-        return node;
-    }
-
-
-    getFunctionExistingNames(excludedList: Array<Function> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.functions as Function[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getFunctionUniqueName(name = 'func1') {
-        return utils.unique(name, this.getFunctionExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入函数
-    * @internal
-    * @param name 函数名称，如果不填会自动生成一个唯一名称
-    */
-    _insertFunctionAt(name: string, index: number): Function;
-
-    /**
-    * 插入函数
-    * @internal
-    * @param funcOptions 函数参数
-    */
-    _insertFunctionAt(funcOptions: Partial<Function>, index: number): Function;
-
-    /**
-    * 插入函数
-    * @internal
-    * @param func 已有的函数实例
-    */
-    _insertFunctionAt(func: Function, index: number): Function;
-
-    _insertFunctionAt(options: string | Partial<Function> | Function, index: number) {
-        const funcOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'functions' };
-        let func: Function;
-        if (!options) {
-            func = Function.from({
-                ...funcOptions,
-                name: this.getFunctionUniqueName(),
-            }, this, 'functions');
-        } else if (typeof options === 'string') {
-            func = Function.from({
-                ...funcOptions,
-                name: options,
-            }, this, 'functions');
-        } else if (options instanceof Function) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            func = options;
-            Object.assign(func, relationOptions);
-        } else {
-            func = Function.from({
-                ...funcOptions,
-                ...options,
-            }, this, 'functions');
-        }
-        this.functions.splice(index, 0, func);
-        return func;
-    }
-
-    /**
-     * 插入函数
-     * @param name 函数名称，如果不填会自动生成一个唯一名称
-     */
-    insertFunctionAt(name: string, index: number): Function;
-
-    /**
-     * 插入函数
-     * @param funcOptions 函数参数
-     */
-    insertFunctionAt(funcOptions: Partial<Function>, index: number): Function;
-
-    /**
-     * 插入函数
-     * @param func 已有的函数实例
-     */
-    insertFunctionAt(func: Function, index: number): Function;
-
-    insertFunctionAt(options: string | Partial<Function> | Function, index: number) {
-        const node = this._insertFunctionAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'functions',
-        });
-        return node;
-    }
-
-    /**
-     * 添加函数
-     * @internal
-     * @param name 函数名称，如果不填会自动生成一个唯一名称
-     */
-    _addFunction(name?: string): Function;
-
-    /**
-     * 添加函数
-     * @internal
-     * @param funcOptions 函数参数
-     */
-    _addFunction(funcOptions: Partial<Function>): Function;
-
-    /**
-     * 添加函数
-     * @internal
-     * @param func 已有的函数实例
-     */
-    _addFunction(func: Function): Function;
-
-    _addFunction(options?: string | Partial<Function> | Function) {
-        const index = 0;
-        return this._insertFunctionAt(options as any, index);
-    }
-
-    /**
-     * 添加函数
-     * @internal
-     * @param name 函数名称，如果不填会自动生成一个唯一名称
-     */
-    addFunction(name?: string): Function;
-
-    /**
-     * 添加函数
-     * @param funcOptions 函数参数
-     */
-    addFunction(funcOptions: Partial<Function>): Function;
-
-    /**
-     * 添加函数
-     * @param func 已有的函数实例
-     */
-    addFunction(func: Function): Function;
-
-    addFunction(options?: string | Partial<Function> | Function) {
-        const node = this._addFunction(options as any);
-        const index = this.functions.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'functions',
-        });
-        return node;
-    }
-
-
-    getInterfaceExistingNames(excludedList: Array<Interface> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getInterfaceUniqueName(name = 'Interface1') {
-        return utils.unique(name, this.getInterfaceExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入接口
-    * @internal
-    * @param name 接口名称，如果不填会自动生成一个唯一名称
-    */
-    _insertInterfaceAt(name: string, index: number): Interface;
-
-    /**
-    * 插入接口
-    * @internal
-    * @param itfaceOptions 接口参数
-    */
-    _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
-
-    /**
-    * 插入接口
-    * @internal
-    * @param itface 已有的接口实例
-    */
-    _insertInterfaceAt(itface: Interface, index: number): Interface;
-
-    _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
-        const itfaceOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
-        let itface: Interface;
-        if (!options) {
-            itface = Interface.from({
-                ...itfaceOptions,
-                name: this.getInterfaceUniqueName(),
-            }, this, 'interfaces');
-        } else if (typeof options === 'string') {
-            itface = Interface.from({
-                ...itfaceOptions,
-                name: options,
-            }, this, 'interfaces');
-        } else if (options instanceof Interface) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            itface = options;
-            Object.assign(itface, relationOptions);
-        } else {
-            itface = Interface.from({
-                ...itfaceOptions,
-                ...options,
-            }, this, 'interfaces');
-        }
-        this.interfaces.splice(index, 0, itface);
-        return itface;
-    }
-
-    /**
-     * 插入接口
-     * @param name 接口名称，如果不填会自动生成一个唯一名称
-     */
-    insertInterfaceAt(name: string, index: number): Interface;
-
-    /**
-     * 插入接口
-     * @param itfaceOptions 接口参数
-     */
-    insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
-
-    /**
-     * 插入接口
-     * @param itface 已有的接口实例
-     */
-    insertInterfaceAt(itface: Interface, index: number): Interface;
-
-    insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
-        const node = this._insertInterfaceAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'interfaces',
-        });
-        return node;
-    }
-
-    /**
-     * 添加接口
-     * @internal
-     * @param name 接口名称，如果不填会自动生成一个唯一名称
-     */
-    _addInterface(name?: string): Interface;
-
-    /**
-     * 添加接口
-     * @internal
-     * @param itfaceOptions 接口参数
-     */
-    _addInterface(itfaceOptions: Partial<Interface>): Interface;
-
-    /**
-     * 添加接口
-     * @internal
-     * @param itface 已有的接口实例
-     */
-    _addInterface(itface: Interface): Interface;
-
-    _addInterface(options?: string | Partial<Interface> | Interface) {
-        const index = 0;
-        return this._insertInterfaceAt(options as any, index);
-    }
-
-    /**
-     * 添加接口
-     * @internal
-     * @param name 接口名称，如果不填会自动生成一个唯一名称
-     */
-    addInterface(name?: string): Interface;
-
-    /**
-     * 添加接口
-     * @param itfaceOptions 接口参数
-     */
-    addInterface(itfaceOptions: Partial<Interface>): Interface;
-
-    /**
-     * 添加接口
-     * @param itface 已有的接口实例
-     */
-    addInterface(itface: Interface): Interface;
-
-    addInterface(options?: string | Partial<Interface> | Interface) {
-        const node = this._addInterface(options as any);
-        const index = this.interfaces.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'interfaces',
-        });
-        return node;
-    }
-
-
-    getViewExistingNames(excludedList: Array<View> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.views as View[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getViewUniqueName(name = 'view1') {
-        return utils.unique(name, this.getViewExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入页面
-    * @internal
-    * @param name 页面名称，如果不填会自动生成一个唯一名称
-    */
-    _insertViewAt(name: string, index: number): View;
-
-    /**
-    * 插入页面
-    * @internal
-    * @param viewOptions 页面参数
-    */
-    _insertViewAt(viewOptions: Partial<View>, index: number): View;
-
-    /**
-    * 插入页面
-    * @internal
-    * @param view 已有的页面实例
-    */
-    _insertViewAt(view: View, index: number): View;
-
-    _insertViewAt(options: string | Partial<View> | View, index: number) {
-        const viewOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'views' };
-        let view: View;
-        if (!options) {
-            view = View.from({
-                ...viewOptions,
-                name: this.getViewUniqueName(),
-            }, this, 'views');
-        } else if (typeof options === 'string') {
-            view = View.from({
-                ...viewOptions,
-                name: options,
-            }, this, 'views');
-        } else if (options instanceof View) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            view = options;
-            Object.assign(view, relationOptions);
-        } else {
-            view = View.from({
-                ...viewOptions,
-                ...options,
-            }, this, 'views');
-        }
-        this.views.splice(index, 0, view);
-        return view;
-    }
-
-    /**
-     * 插入页面
-     * @param name 页面名称，如果不填会自动生成一个唯一名称
-     */
-    insertViewAt(name: string, index: number): View;
-
-    /**
-     * 插入页面
-     * @param viewOptions 页面参数
-     */
-    insertViewAt(viewOptions: Partial<View>, index: number): View;
-
-    /**
-     * 插入页面
-     * @param view 已有的页面实例
-     */
-    insertViewAt(view: View, index: number): View;
-
-    insertViewAt(options: string | Partial<View> | View, index: number) {
-        const node = this._insertViewAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'views',
-        });
-        return node;
-    }
-
-    /**
-     * 添加页面
-     * @internal
-     * @param name 页面名称，如果不填会自动生成一个唯一名称
-     */
-    _addView(name?: string): View;
-
-    /**
-     * 添加页面
-     * @internal
-     * @param viewOptions 页面参数
-     */
-    _addView(viewOptions: Partial<View>): View;
-
-    /**
-     * 添加页面
-     * @internal
-     * @param view 已有的页面实例
-     */
-    _addView(view: View): View;
-
-    _addView(options?: string | Partial<View> | View) {
-        const index = this.views.length;
-        return this._insertViewAt(options as any, index);
-    }
-
-    /**
-     * 添加页面
-     * @internal
-     * @param name 页面名称，如果不填会自动生成一个唯一名称
-     */
-    addView(name?: string): View;
-
-    /**
-     * 添加页面
-     * @param viewOptions 页面参数
-     */
-    addView(viewOptions: Partial<View>): View;
-
-    /**
-     * 添加页面
-     * @param view 已有的页面实例
-     */
-    addView(view: View): View;
-
-    addView(options?: string | Partial<View> | View) {
-        const node = this._addView(options as any);
-        const index = this.views.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'views',
-        });
-        return node;
-    }
-
-
-    getVarExistingNames(excludedList: Array<Variable> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.frontendVariables as Variable[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getVariableUniqueName(name = 'variable1') {
-        return utils.unique(name, this.getVarExistingNames(), undefined, true);
-    }
-
-    /**
-    * 插入变量
-    * @internal
-    * @param name 变量名称，如果不填会自动生成一个唯一名称
-    */
-    _insertVariableInFrontendVariablesAt(name: string, index: number): Variable;
-
-    /**
-    * 插入变量
-    * @internal
-    * @param variableOptions 变量参数
-    */
-    _insertVariableInFrontendVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
-
-    /**
-    * 插入变量
-    * @internal
-    * @param variable 已有的变量实例
-    */
-    _insertVariableInFrontendVariablesAt(variable: Variable, index: number): Variable;
-
-    _insertVariableInFrontendVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
-        const variableOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'frontendVariables' };
-        let variable: Variable;
-        if (!options) {
-            variable = Variable.from({
-                ...variableOptions,
-                name: this.getVariableUniqueName(),
-            }, this, 'frontendVariables');
-        } else if (typeof options === 'string') {
-            variable = Variable.from({
-                ...variableOptions,
-                name: options,
-            }, this, 'frontendVariables');
-        } else if (options instanceof Variable) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            variable = options;
-            Object.assign(variable, relationOptions);
-        } else {
-            variable = Variable.from({
-                ...variableOptions,
-                ...options,
-            }, this, 'frontendVariables');
-        }
-        this.frontendVariables.splice(index, 0, variable);
-        return variable;
-    }
-
-    /**
-     * 插入变量
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
-     */
-    insertVariableInFrontendVariablesAt(name: string, index: number): Variable;
-
-    /**
-     * 插入变量
-     * @param variableOptions 变量参数
-     */
-    insertVariableInFrontendVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
-
-    /**
-     * 插入变量
-     * @param variable 已有的变量实例
-     */
-    insertVariableInFrontendVariablesAt(variable: Variable, index: number): Variable;
-
-    insertVariableInFrontendVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
-        const node = this._insertVariableInFrontendVariablesAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'frontendVariables',
-        });
-        return node;
-    }
-
-    /**
-     * 添加变量
-     * @internal
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
-     */
-    _addVariableInFrontendVariables(name?: string): Variable;
-
-    /**
-     * 添加变量
-     * @internal
-     * @param variableOptions 变量参数
-     */
-    _addVariableInFrontendVariables(variableOptions: Partial<Variable>): Variable;
-
-    /**
-     * 添加变量
-     * @internal
-     * @param variable 已有的变量实例
-     */
-    _addVariableInFrontendVariables(variable: Variable): Variable;
-
-    _addVariableInFrontendVariables(options?: string | Partial<Variable> | Variable) {
-        const index = this.frontendVariables.length;
-        return this._insertVariableInFrontendVariablesAt(options as any, index);
-    }
-
-    /**
-     * 添加变量
-     * @internal
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
-     */
-    addVariableInFrontendVariables(name?: string): Variable;
-
-    /**
-     * 添加变量
-     * @param variableOptions 变量参数
-     */
-    addVariableInFrontendVariables(variableOptions: Partial<Variable>): Variable;
-
-    /**
-     * 添加变量
-     * @param variable 已有的变量实例
-     */
-    addVariableInFrontendVariables(variable: Variable): Variable;
-
-    addVariableInFrontendVariables(options?: string | Partial<Variable> | Variable) {
-        const node = this._addVariableInFrontendVariables(options as any);
-        const index = this.frontendVariables.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'frontendVariables',
-        });
-        return node;
-    }
-
-    /**
-    * 插入变量
-    * @internal
-    * @param name 变量名称，如果不填会自动生成一个唯一名称
-    */
-    _insertVariableInVariablesAt(name: string, index: number): Variable;
-
-    /**
-    * 插入变量
-    * @internal
-    * @param variableOptions 变量参数
-    */
-    _insertVariableInVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
-
-    /**
-    * 插入变量
-    * @internal
-    * @param variable 已有的变量实例
-    */
-    _insertVariableInVariablesAt(variable: Variable, index: number): Variable;
-
-    _insertVariableInVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
-        const variableOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'variables' };
-        let variable: Variable;
-        if (!options) {
-            variable = Variable.from({
-                ...variableOptions,
-                name: this.getVariableUniqueName(),
-            }, this, 'variables');
-        } else if (typeof options === 'string') {
-            variable = Variable.from({
-                ...variableOptions,
-                name: options,
-            }, this, 'variables');
-        } else if (options instanceof Variable) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            variable = options;
-            Object.assign(variable, relationOptions);
-        } else {
-            variable = Variable.from({
-                ...variableOptions,
-                ...options,
-            }, this, 'variables');
-        }
-        this.variables.splice(index, 0, variable);
-        return variable;
-    }
-
-    /**
-     * 插入变量
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
-     */
-    insertVariableInVariablesAt(name: string, index: number): Variable;
-
-    /**
-     * 插入变量
-     * @param variableOptions 变量参数
-     */
-    insertVariableInVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
-
-    /**
-     * 插入变量
-     * @param variable 已有的变量实例
-     */
-    insertVariableInVariablesAt(variable: Variable, index: number): Variable;
-
-    insertVariableInVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
-        const node = this._insertVariableInVariablesAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'variables',
-        });
-        return node;
-    }
-
-    /**
-     * 添加变量
-     * @internal
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
-     */
-    _addVariableInVariables(name?: string): Variable;
-
-    /**
-     * 添加变量
-     * @internal
-     * @param variableOptions 变量参数
-     */
-    _addVariableInVariables(variableOptions: Partial<Variable>): Variable;
-
-    /**
-     * 添加变量
-     * @internal
-     * @param variable 已有的变量实例
-     */
-    _addVariableInVariables(variable: Variable): Variable;
-
-    _addVariableInVariables(options?: string | Partial<Variable> | Variable) {
-        const index = this.variables.length;
-        return this._insertVariableInVariablesAt(options as any, index);
-    }
-
-    /**
-     * 添加变量
-     * @internal
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
-     */
-    addVariableInVariables(name?: string): Variable;
-
-    /**
-     * 添加变量
-     * @param variableOptions 变量参数
-     */
-    addVariableInVariables(variableOptions: Partial<Variable>): Variable;
-
-    /**
-     * 添加变量
-     * @param variable 已有的变量实例
-     */
-    addVariableInVariables(variable: Variable): Variable;
-
-    addVariableInVariables(options?: string | Partial<Variable> | Variable) {
-        const node = this._addVariableInVariables(options as any);
-        const index = this.variables.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'variables',
-        });
-        return node;
-    }
-
-
-    getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.viewComponents as ViewComponent[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getViewComponentUniqueName(name = 'viewComponent1') {
-        return utils.unique(name, this.getViewComponentExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入页面组件
-    * @internal
-    * @param name 页面组件名称，如果不填会自动生成一个唯一名称
-    */
-    _insertViewComponentAt(name: string, index: number): ViewComponent;
-
-    /**
-    * 插入页面组件
-    * @internal
-    * @param viewComponentOptions 页面组件参数
-    */
-    _insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
-
-    /**
-    * 插入页面组件
-    * @internal
-    * @param viewComponent 已有的页面组件实例
-    */
-    _insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
-
-    _insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
-        const viewComponentOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'viewComponents' };
-        let viewComponent: ViewComponent;
-        if (!options) {
-            viewComponent = ViewComponent.from({
-                ...viewComponentOptions,
-                name: this.getViewComponentUniqueName(),
-            }, this, 'viewComponents');
-        } else if (typeof options === 'string') {
-            viewComponent = ViewComponent.from({
-                ...viewComponentOptions,
-                name: options,
-            }, this, 'viewComponents');
-        } else if (options instanceof ViewComponent) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            viewComponent = options;
-            Object.assign(viewComponent, relationOptions);
-        } else {
-            viewComponent = ViewComponent.from({
-                ...viewComponentOptions,
-                ...options,
-            }, this, 'viewComponents');
-        }
-        this.viewComponents.splice(index, 0, viewComponent);
-        return viewComponent;
-    }
-
-    /**
-     * 插入页面组件
-     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
-     */
-    insertViewComponentAt(name: string, index: number): ViewComponent;
-
-    /**
-     * 插入页面组件
-     * @param viewComponentOptions 页面组件参数
-     */
-    insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
-
-    /**
-     * 插入页面组件
-     * @param viewComponent 已有的页面组件实例
-     */
-    insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
-
-    insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
-        const node = this._insertViewComponentAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'viewComponents',
-        });
-        return node;
-    }
-
-    /**
-     * 添加页面组件
-     * @internal
-     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
-     */
-    _addViewComponent(name?: string): ViewComponent;
-
-    /**
-     * 添加页面组件
-     * @internal
-     * @param viewComponentOptions 页面组件参数
-     */
-    _addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
-
-    /**
-     * 添加页面组件
-     * @internal
-     * @param viewComponent 已有的页面组件实例
-     */
-    _addViewComponent(viewComponent: ViewComponent): ViewComponent;
-
-    _addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
-        const index = this.viewComponents.length;
-        return this._insertViewComponentAt(options as any, index);
-    }
-
-    /**
-     * 添加页面组件
-     * @internal
-     * @param name 页面组件名称，如果不填会自动生成一个唯一名称
-     */
-    addViewComponent(name?: string): ViewComponent;
-
-    /**
-     * 添加页面组件
-     * @param viewComponentOptions 页面组件参数
-     */
-    addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
-
-    /**
-     * 添加页面组件
-     * @param viewComponent 已有的页面组件实例
-     */
-    addViewComponent(viewComponent: ViewComponent): ViewComponent;
-
-    addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
-        const node = this._addViewComponent(options as any);
-        const index = this.viewComponents.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'viewComponents',
-        });
-        return node;
-    }
-
-
-    getProcessComponentExistingNames(excludedList: Array<ProcessComponent> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.processComponents as ProcessComponent[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getProcessComponentUniqueName(name = 'processComponent1') {
-        return utils.unique(name, this.getProcessComponentExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入流程组件
-    * @internal
-    * @param name 流程组件名称，如果不填会自动生成一个唯一名称
-    */
-    _insertProcessComponentAt(name: string, index: number): ProcessComponent;
-
-    /**
-    * 插入流程组件
-    * @internal
-    * @param processComponentOptions 流程组件参数
-    */
-    _insertProcessComponentAt(processComponentOptions: Partial<ProcessComponent>, index: number): ProcessComponent;
-
-    /**
-    * 插入流程组件
-    * @internal
-    * @param processComponent 已有的流程组件实例
-    */
-    _insertProcessComponentAt(processComponent: ProcessComponent, index: number): ProcessComponent;
-
-    _insertProcessComponentAt(options: string | Partial<ProcessComponent> | ProcessComponent, index: number) {
-        const processComponentOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'processComponents' };
-        let processComponent: ProcessComponent;
-        if (!options) {
-            processComponent = ProcessComponent.from({
-                ...processComponentOptions,
-                name: this.getProcessComponentUniqueName(),
-            }, this, 'processComponents');
-        } else if (typeof options === 'string') {
-            processComponent = ProcessComponent.from({
-                ...processComponentOptions,
-                name: options,
-            }, this, 'processComponents');
-        } else if (options instanceof ProcessComponent) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            processComponent = options;
-            Object.assign(processComponent, relationOptions);
-        } else {
-            processComponent = ProcessComponent.from({
-                ...processComponentOptions,
-                ...options,
-            }, this, 'processComponents');
-        }
-        this.processComponents.splice(index, 0, processComponent);
-        return processComponent;
-    }
-
-    /**
-     * 插入流程组件
-     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
-     */
-    insertProcessComponentAt(name: string, index: number): ProcessComponent;
-
-    /**
-     * 插入流程组件
-     * @param processComponentOptions 流程组件参数
-     */
-    insertProcessComponentAt(processComponentOptions: Partial<ProcessComponent>, index: number): ProcessComponent;
-
-    /**
-     * 插入流程组件
-     * @param processComponent 已有的流程组件实例
-     */
-    insertProcessComponentAt(processComponent: ProcessComponent, index: number): ProcessComponent;
-
-    insertProcessComponentAt(options: string | Partial<ProcessComponent> | ProcessComponent, index: number) {
-        const node = this._insertProcessComponentAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'processComponents',
-        });
-        return node;
-    }
-
-    /**
-     * 添加流程组件
-     * @internal
-     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
-     */
-    _addProcessComponent(name?: string): ProcessComponent;
-
-    /**
-     * 添加流程组件
-     * @internal
-     * @param processComponentOptions 流程组件参数
-     */
-    _addProcessComponent(processComponentOptions: Partial<ProcessComponent>): ProcessComponent;
-
-    /**
-     * 添加流程组件
-     * @internal
-     * @param processComponent 已有的流程组件实例
-     */
-    _addProcessComponent(processComponent: ProcessComponent): ProcessComponent;
-
-    _addProcessComponent(options?: string | Partial<ProcessComponent> | ProcessComponent) {
-        const index = this.processComponents.length;
-        return this._insertProcessComponentAt(options as any, index);
-    }
-
-    /**
-     * 添加流程组件
-     * @internal
-     * @param name 流程组件名称，如果不填会自动生成一个唯一名称
-     */
-    addProcessComponent(name?: string): ProcessComponent;
-
-    /**
-     * 添加流程组件
-     * @param processComponentOptions 流程组件参数
-     */
-    addProcessComponent(processComponentOptions: Partial<ProcessComponent>): ProcessComponent;
-
-    /**
-     * 添加流程组件
-     * @param processComponent 已有的流程组件实例
-     */
-    addProcessComponent(processComponent: ProcessComponent): ProcessComponent;
-
-    addProcessComponent(options?: string | Partial<ProcessComponent> | ProcessComponent) {
-        const node = this._addProcessComponent(options as any);
-        const index = this.processComponents.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'processComponents',
-        });
-        return node;
-    }
-
-
-    
-
-    /**
-    * 删除命名空间
-    * @param name 命名空间名称
-    */
-    removeNamespace(name: string): void;
-
-    /**
-     * 删除命名空间
-     * @param namespace 已有的命名空间实例
-     */
-    removeNamespace(namespace: Namespace): void;
-
-    removeNamespace(options: string | Namespace) {
-        let namespace: Namespace;
-        if (typeof options === 'string') {
-            namespace = (this.children as Namespace[]).find((item) => item.name === options);
-            if (!namespace) {
-                throw new Error('找不到命名空间 ' + options);
-            }
-        } else {
-            namespace = options;
-        }
-        return namespace.delete();
-    }
-
-    __removeNamespace(namespace: Namespace) {
-        const parentKey = namespace.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: namespace,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(namespace);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === namespace) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除流程
-    * @param name 流程名称
-    */
-    removeProcess(name: string): void;
-
-    /**
-     * 删除流程
-     * @param process 已有的流程实例
-     */
-    removeProcess(process: Process): void;
-
-    removeProcess(options: string | Process) {
-        let process: Process;
-        if (typeof options === 'string') {
-            process = (this.processes as Process[]).find((item) => item.name === options);
-            if (!process) {
-                throw new Error('找不到流程 ' + options);
-            }
-        } else {
-            process = options;
-        }
-        return process.delete();
-    }
-
-    __removeProcess(process: Process) {
-        const parentKey = process.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: process,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(process);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === process) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除数据结构
-    * @param name 数据结构名称
-    */
-    removeStructure(name: string): void;
-
-    /**
-     * 删除数据结构
-     * @param structure 已有的数据结构实例
-     */
-    removeStructure(structure: Structure): void;
-
-    removeStructure(options: string | Structure) {
-        let structure: Structure;
-        if (typeof options === 'string') {
-            structure = (this.structures as Structure[]).find((item) => item.name === options);
-            if (!structure) {
-                throw new Error('找不到数据结构 ' + options);
-            }
-        } else {
-            structure = options;
-        }
-        return structure.delete();
-    }
-
-    __removeStructure(structure: Structure) {
-        const parentKey = structure.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: structure,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(structure);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === structure) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除枚举
-    * @param name 枚举名称
-    */
-    removeEnum(name: string): void;
-
-    /**
-     * 删除枚举
-     * @param enumeration 已有的枚举实例
-     */
-    removeEnum(enumeration: Enum): void;
-
-    removeEnum(options: string | Enum) {
-        let enumeration: Enum;
-        if (typeof options === 'string') {
-            enumeration = (this.enums as Enum[]).find((item) => item.name === options);
-            if (!enumeration) {
-                throw new Error('找不到枚举 ' + options);
-            }
-        } else {
-            enumeration = options;
-        }
-        return enumeration.delete();
-    }
-
-    __removeEnum(enumeration: Enum) {
-        const parentKey = enumeration.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: enumeration,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(enumeration);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === enumeration) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除逻辑
-    * @param name 逻辑名称
-    */
-    removeLogic(name: string): void;
-
-    /**
-     * 删除逻辑
-     * @param logic 已有的逻辑实例
-     */
-    removeLogic(logic: Logic): void;
-
-    removeLogic(options: string | Logic) {
-        let logic: Logic;
-        if (typeof options === 'string') {
-            logic = (this.logics as Logic[]).find((item) => item.name === options);
-            if (!logic) {
-                throw new Error('找不到逻辑 ' + options);
-            }
-        } else {
-            logic = options;
-        }
-        return logic.delete();
-    }
-
-    __removeLogic(logic: Logic) {
-        const parentKey = logic.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: logic,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(logic);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === logic) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除函数
-    * @param name 函数名称
-    */
-    removeFunction(name: string): void;
-
-    /**
-     * 删除函数
-     * @param func 已有的函数实例
-     */
-    removeFunction(func: Function): void;
-
-    removeFunction(options: string | Function) {
-        let func: Function;
-        if (typeof options === 'string') {
-            func = (this.functions as Function[]).find((item) => item.name === options);
-            if (!func) {
-                throw new Error('找不到函数 ' + options);
-            }
-        } else {
-            func = options;
-        }
-        return func.delete();
-    }
-
-    __removeFunction(func: Function) {
-        const parentKey = func.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: func,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(func);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === func) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除接口
-    * @param name 接口名称
-    */
-    removeInterface(name: string): void;
-
-    /**
-     * 删除接口
-     * @param itface 已有的接口实例
-     */
-    removeInterface(itface: Interface): void;
-
-    removeInterface(options: string | Interface) {
-        let itface: Interface;
-        if (typeof options === 'string') {
-            itface = (this.interfaces as Interface[]).find((item) => item.name === options);
-            if (!itface) {
-                throw new Error('找不到接口 ' + options);
-            }
-        } else {
-            itface = options;
-        }
-        return itface.delete();
-    }
-
-    __removeInterface(itface: Interface) {
-        const parentKey = itface.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: itface,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(itface);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === itface) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除页面
-    * @param name 页面名称
-    */
-    removeView(name: string): void;
-
-    /**
-     * 删除页面
-     * @param view 已有的页面实例
-     */
-    removeView(view: View): void;
-
-    removeView(options: string | View) {
-        let view: View;
-        if (typeof options === 'string') {
-            view = (this.views as View[]).find((item) => item.name === options);
-            if (!view) {
-                throw new Error('找不到页面 ' + options);
-            }
-        } else {
-            view = options;
-        }
-        return view.delete();
-    }
-
-    __removeView(view: View) {
-        const parentKey = view.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: view,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(view);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === view) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除变量
-    * @param name 变量名称
-    */
-    removeVariableInFrontendVariables(name: string): void;
-
-    /**
-     * 删除变量
-     * @param variable 已有的变量实例
-     */
-    removeVariableInFrontendVariables(variable: Variable): void;
-
-    removeVariableInFrontendVariables(options: string | Variable) {
-        let variable: Variable;
-        if (typeof options === 'string') {
-            variable = (this.frontendVariables as Variable[]).find((item) => item.name === options);
-            if (!variable) {
-                throw new Error('找不到变量 ' + options);
-            }
-        } else {
-            variable = options;
-        }
-        return variable.delete();
-    }
-
-    
-
-    /**
-    * 删除变量
-    * @param name 变量名称
-    */
-    removeVariableInVariables(name: string): void;
-
-    /**
-     * 删除变量
-     * @param variable 已有的变量实例
-     */
-    removeVariableInVariables(variable: Variable): void;
-
-    removeVariableInVariables(options: string | Variable) {
-        let variable: Variable;
-        if (typeof options === 'string') {
-            variable = (this.variables as Variable[]).find((item) => item.name === options);
-            if (!variable) {
-                throw new Error('找不到变量 ' + options);
-            }
-        } else {
-            variable = options;
-        }
-        return variable.delete();
-    }
-
-    __removeVariable(variable: Variable) {
-        const parentKey = variable.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: variable,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(variable);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === variable) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除页面组件
-    * @param name 页面组件名称
-    */
-    removeViewComponent(name: string): void;
-
-    /**
-     * 删除页面组件
-     * @param viewComponent 已有的页面组件实例
-     */
-    removeViewComponent(viewComponent: ViewComponent): void;
-
-    removeViewComponent(options: string | ViewComponent) {
-        let viewComponent: ViewComponent;
-        if (typeof options === 'string') {
-            viewComponent = (this.viewComponents as ViewComponent[]).find((item) => item.name === options);
-            if (!viewComponent) {
-                throw new Error('找不到页面组件 ' + options);
-            }
-        } else {
-            viewComponent = options;
-        }
-        return viewComponent.delete();
-    }
-
-    __removeViewComponent(viewComponent: ViewComponent) {
-        const parentKey = viewComponent.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: viewComponent,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(viewComponent);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === viewComponent) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除流程组件
-    * @param name 流程组件名称
-    */
-    removeProcessComponent(name: string): void;
-
-    /**
-     * 删除流程组件
-     * @param processComponent 已有的流程组件实例
-     */
-    removeProcessComponent(processComponent: ProcessComponent): void;
-
-    removeProcessComponent(options: string | ProcessComponent) {
-        let processComponent: ProcessComponent;
-        if (typeof options === 'string') {
-            processComponent = (this.processComponents as ProcessComponent[]).find((item) => item.name === options);
-            if (!processComponent) {
-                throw new Error('找不到流程组件 ' + options);
-            }
-        } else {
-            processComponent = options;
-        }
-        return processComponent.delete();
-    }
-
-    __removeProcessComponent(processComponent: ProcessComponent) {
-        const parentKey = processComponent.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: processComponent,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(processComponent);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === processComponent) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-
-    findEnumByName(name: string) {
-        return this.enums.find((enumItem) => enumItem.name === name);
-    }
-
-    findStructureByName(name: string) {
-        return this.structures.find((item) => item.name === name);
-    }
-
-    findLogicByName(name: string) {
-        return this.logics.find((logic) => logic.name === name);
-    }
-
-    @property()
-    path: string = undefined;
-
-    /**
-     * 获取命名空间
-     */
-    getNamespace(): string {
-        if (this.path)
-            return this.path;
-        else if (this.parentNode && (this.parentNode as Namespace).getNamespace)
-            return `${(this.parentNode as Namespace).getNamespace()}`;
-        else
-            throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
-    }
-
-    /**
-     * 获取命名空间
-     */
-    getTsNamespace(): string {
-        if (this.path)
-            return this.path;
-        else if (this.parentNode && (this.parentNode as Namespace).getNamespace)
-            return `${(this.parentNode as Namespace).getNamespace()}.${this.tsName}`;
-        else
-            throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
-    }
-
-    findChild(name: string) {
-        return this.children.find((child) => child.name === name);
-    }
-
-    findLogic(name: string) {
-        return this.logics.find((logic) => logic.name === name);
-    }
-
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'Namespace' = 'Namespace';
+
+  /**
+   * 表示是从实体还是流程等概念产生的
+   */
+  @property()
+  originConcept: string = undefined;
+
+  /**
+   * 命名空间名称
+   */
+  @property()
+  name: string = undefined;
+
+  /**
+   * 命名空间标题
+   */
+  @property()
+  title: string = undefined;
+
+  /**
+   * 命名空间描述
+   */
+  @property()
+  description: string = undefined;
+
+  /**
+   * 命名空间列表
+   */
+  @property('Namespace')
+  children: Array<Namespace> = [];
+
+  /**
+   * 流程列表
+   */
+  @property('Process')
+  processes: Array<Process> = [];
+
+  /**
+   * 数据结构列表
+   */
+  @property('Structure')
+  structures: Array<Structure> = [];
+
+  /**
+   * 枚举列表
+   */
+  @property('Enum')
+  enums: Array<Enum> = [];
+
+  /**
+   * 逻辑列表
+   */
+  @property('Logic')
+  logics: Array<Logic> = [];
+
+  /**
+   * 函数列表
+   */
+  @property('Function')
+  functions: Array<Function> = [];
+
+  /**
+   * 接口列表
+   */
+  @property('Interface')
+  interfaces: Array<Interface> = [];
+
+  /**
+   * 页面列表
+   */
+  @property('View')
+  views: Array<View> = [];
+
+  /**
+   * 变量列表
+   */
+  @property('Variable')
+  frontendVariables: Array<Variable> = [];
+
+  /**
+   * 变量列表
+   */
+  @property('Variable')
+  variables: Array<Variable> = [];
+
+  /**
+   * 页面组件列表
+   */
+  @property('ViewComponent')
+  viewComponents: Array<ViewComponent> = [];
+
+  /**
+   * 流程组件列表
+   */
+  @property('ProcessComponent')
+  processComponents: Array<ProcessComponent> = [];
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<Namespace>) {
+    // @ts-ignore
+    source = { ...Namespace.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'Namespace';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): Namespace {
+    return super.from(source, parentNode, parentKey) as Namespace;
+  }
+
+  /**
+   * 从父级删除该节点
+   * @internal
+   */
+  _delete() {
+    let params: Params = null;
+    if (this.parentNode) {
+      params = (this.parentNode as any)?.__removeNamespace?.(this);
+    }
+    return params;
+  }
+
+  getNamespaceExistingNames(excludedList: Array<Namespace> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.children as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getNamespaceUniqueName(name = 'namespace1') {
+    return utils.unique(name, this.getNamespaceExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入命名空间
+   * @internal
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  _insertNamespaceAt(name: string, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @internal
+   * @param namespaceOptions 命名空间参数
+   */
+  _insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @internal
+   * @param namespace 已有的命名空间实例
+   */
+  _insertNamespaceAt(namespace: Namespace, index: number): Namespace;
+
+  _insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
+    const namespaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'children' };
+    let namespace: Namespace;
+    if (!options) {
+      namespace = Namespace.from(
+        {
+          ...namespaceOptions,
+          name: this.getNamespaceUniqueName(),
+        },
+        this,
+        'children'
+      );
+    } else if (typeof options === 'string') {
+      namespace = Namespace.from(
+        {
+          ...namespaceOptions,
+          name: options,
+        },
+        this,
+        'children'
+      );
+    } else if (options instanceof Namespace) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      namespace = options;
+      Object.assign(namespace, relationOptions);
+    } else {
+      namespace = Namespace.from(
+        {
+          ...namespaceOptions,
+          ...options,
+        },
+        this,
+        'children'
+      );
+    }
+    this.children.splice(index, 0, namespace);
+    return namespace;
+  }
+
+  /**
+   * 插入命名空间
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  insertNamespaceAt(name: string, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @param namespaceOptions 命名空间参数
+   */
+  insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @param namespace 已有的命名空间实例
+   */
+  insertNamespaceAt(namespace: Namespace, index: number): Namespace;
+
+  insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
+    const node = this._insertNamespaceAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'children',
+    });
+    return node;
+  }
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  _addNamespace(name?: string): Namespace;
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param namespaceOptions 命名空间参数
+   */
+  _addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param namespace 已有的命名空间实例
+   */
+  _addNamespace(namespace: Namespace): Namespace;
+
+  _addNamespace(options?: string | Partial<Namespace> | Namespace) {
+    const index = this.children.length;
+    return this._insertNamespaceAt(options as any, index);
+  }
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  addNamespace(name?: string): Namespace;
+
+  /**
+   * 添加命名空间
+   * @param namespaceOptions 命名空间参数
+   */
+  addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
+
+  /**
+   * 添加命名空间
+   * @param namespace 已有的命名空间实例
+   */
+  addNamespace(namespace: Namespace): Namespace;
+
+  addNamespace(options?: string | Partial<Namespace> | Namespace) {
+    const node = this._addNamespace(options as any);
+    const index = this.children.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'children',
+    });
+    return node;
+  }
+
+  getProcessExistingNames(excludedList: Array<Process> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.processes as Process[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getProcessUniqueName(name = 'Process1') {
+    return utils.unique(name, this.getProcessExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入流程
+   * @internal
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   */
+  _insertProcessAt(name: string, index: number): Process;
+
+  /**
+   * 插入流程
+   * @internal
+   * @param processOptions 流程参数
+   */
+  _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
+
+  /**
+   * 插入流程
+   * @internal
+   * @param process 已有的流程实例
+   */
+  _insertProcessAt(process: Process, index: number): Process;
+
+  _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
+    const processOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'processes' };
+    let process: Process;
+    if (!options) {
+      process = Process.from(
+        {
+          ...processOptions,
+          name: this.getProcessUniqueName(),
+        },
+        this,
+        'processes'
+      );
+    } else if (typeof options === 'string') {
+      process = Process.from(
+        {
+          ...processOptions,
+          name: options,
+        },
+        this,
+        'processes'
+      );
+    } else if (options instanceof Process) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      process = options;
+      Object.assign(process, relationOptions);
+    } else {
+      process = Process.from(
+        {
+          ...processOptions,
+          ...options,
+        },
+        this,
+        'processes'
+      );
+    }
+    this.processes.splice(index, 0, process);
+    return process;
+  }
+
+  /**
+   * 插入流程
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   */
+  insertProcessAt(name: string, index: number): Process;
+
+  /**
+   * 插入流程
+   * @param processOptions 流程参数
+   */
+  insertProcessAt(processOptions: Partial<Process>, index: number): Process;
+
+  /**
+   * 插入流程
+   * @param process 已有的流程实例
+   */
+  insertProcessAt(process: Process, index: number): Process;
+
+  insertProcessAt(options: string | Partial<Process> | Process, index: number) {
+    const node = this._insertProcessAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'processes',
+    });
+    return node;
+  }
+
+  /**
+   * 添加流程
+   * @internal
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   */
+  _addProcess(name?: string): Process;
+
+  /**
+   * 添加流程
+   * @internal
+   * @param processOptions 流程参数
+   */
+  _addProcess(processOptions: Partial<Process>): Process;
+
+  /**
+   * 添加流程
+   * @internal
+   * @param process 已有的流程实例
+   */
+  _addProcess(process: Process): Process;
+
+  _addProcess(options?: string | Partial<Process> | Process) {
+    const index = 0;
+    return this._insertProcessAt(options as any, index);
+  }
+
+  /**
+   * 添加流程
+   * @internal
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   */
+  addProcess(name?: string): Process;
+
+  /**
+   * 添加流程
+   * @param processOptions 流程参数
+   */
+  addProcess(processOptions: Partial<Process>): Process;
+
+  /**
+   * 添加流程
+   * @param process 已有的流程实例
+   */
+  addProcess(process: Process): Process;
+
+  addProcess(options?: string | Partial<Process> | Process) {
+    const node = this._addProcess(options as any);
+    const index = this.processes.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'processes',
+    });
+    return node;
+  }
+
+  getStructureExistingNames(excludedList: Array<Structure> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getStructureUniqueName(name = 'Structure1') {
+    return utils.unique(name, this.getStructureExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入数据结构
+   * @internal
+   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   */
+  _insertStructureAt(name: string, index: number): Structure;
+
+  /**
+   * 插入数据结构
+   * @internal
+   * @param structureOptions 数据结构参数
+   */
+  _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
+
+  /**
+   * 插入数据结构
+   * @internal
+   * @param structure 已有的数据结构实例
+   */
+  _insertStructureAt(structure: Structure, index: number): Structure;
+
+  _insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
+    const structureOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'structures' };
+    let structure: Structure;
+    if (!options) {
+      structure = Structure.from(
+        {
+          ...structureOptions,
+          name: this.getStructureUniqueName(),
+        },
+        this,
+        'structures'
+      );
+    } else if (typeof options === 'string') {
+      structure = Structure.from(
+        {
+          ...structureOptions,
+          name: options,
+        },
+        this,
+        'structures'
+      );
+    } else if (options instanceof Structure) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      structure = options;
+      Object.assign(structure, relationOptions);
+    } else {
+      structure = Structure.from(
+        {
+          ...structureOptions,
+          ...options,
+        },
+        this,
+        'structures'
+      );
+    }
+    this.structures.splice(index, 0, structure);
+    return structure;
+  }
+
+  /**
+   * 插入数据结构
+   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   */
+  insertStructureAt(name: string, index: number): Structure;
+
+  /**
+   * 插入数据结构
+   * @param structureOptions 数据结构参数
+   */
+  insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
+
+  /**
+   * 插入数据结构
+   * @param structure 已有的数据结构实例
+   */
+  insertStructureAt(structure: Structure, index: number): Structure;
+
+  insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
+    const node = this._insertStructureAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'structures',
+    });
+    return node;
+  }
+
+  /**
+   * 添加数据结构
+   * @internal
+   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   */
+  _addStructure(name?: string): Structure;
+
+  /**
+   * 添加数据结构
+   * @internal
+   * @param structureOptions 数据结构参数
+   */
+  _addStructure(structureOptions: Partial<Structure>): Structure;
+
+  /**
+   * 添加数据结构
+   * @internal
+   * @param structure 已有的数据结构实例
+   */
+  _addStructure(structure: Structure): Structure;
+
+  _addStructure(options?: string | Partial<Structure> | Structure) {
+    const index = 0;
+    return this._insertStructureAt(options as any, index);
+  }
+
+  /**
+   * 添加数据结构
+   * @internal
+   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   */
+  addStructure(name?: string): Structure;
+
+  /**
+   * 添加数据结构
+   * @param structureOptions 数据结构参数
+   */
+  addStructure(structureOptions: Partial<Structure>): Structure;
+
+  /**
+   * 添加数据结构
+   * @param structure 已有的数据结构实例
+   */
+  addStructure(structure: Structure): Structure;
+
+  addStructure(options?: string | Partial<Structure> | Structure) {
+    const node = this._addStructure(options as any);
+    const index = this.structures.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'structures',
+    });
+    return node;
+  }
+
+  getEnumExistingNames(excludedList: Array<Enum> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.enums as Enum[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getEnumUniqueName(name = 'Enum1') {
+    return utils.unique(name, this.getEnumExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入枚举
+   * @internal
+   * @param name 枚举名称，如果不填会自动生成一个唯一名称
+   */
+  _insertEnumAt(name: string, index: number): Enum;
+
+  /**
+   * 插入枚举
+   * @internal
+   * @param enumerationOptions 枚举参数
+   */
+  _insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
+
+  /**
+   * 插入枚举
+   * @internal
+   * @param enumeration 已有的枚举实例
+   */
+  _insertEnumAt(enumeration: Enum, index: number): Enum;
+
+  _insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
+    const enumerationOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'enums' };
+    let enumeration: Enum;
+    if (!options) {
+      enumeration = Enum.from(
+        {
+          ...enumerationOptions,
+          name: this.getEnumUniqueName(),
+        },
+        this,
+        'enums'
+      );
+    } else if (typeof options === 'string') {
+      enumeration = Enum.from(
+        {
+          ...enumerationOptions,
+          name: options,
+        },
+        this,
+        'enums'
+      );
+    } else if (options instanceof Enum) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      enumeration = options;
+      Object.assign(enumeration, relationOptions);
+    } else {
+      enumeration = Enum.from(
+        {
+          ...enumerationOptions,
+          ...options,
+        },
+        this,
+        'enums'
+      );
+    }
+    this.enums.splice(index, 0, enumeration);
+    return enumeration;
+  }
+
+  /**
+   * 插入枚举
+   * @param name 枚举名称，如果不填会自动生成一个唯一名称
+   */
+  insertEnumAt(name: string, index: number): Enum;
+
+  /**
+   * 插入枚举
+   * @param enumerationOptions 枚举参数
+   */
+  insertEnumAt(enumerationOptions: Partial<Enum>, index: number): Enum;
+
+  /**
+   * 插入枚举
+   * @param enumeration 已有的枚举实例
+   */
+  insertEnumAt(enumeration: Enum, index: number): Enum;
+
+  insertEnumAt(options: string | Partial<Enum> | Enum, index: number) {
+    const node = this._insertEnumAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'enums',
+    });
+    return node;
+  }
+
+  /**
+   * 添加枚举
+   * @internal
+   * @param name 枚举名称，如果不填会自动生成一个唯一名称
+   */
+  _addEnum(name?: string): Enum;
+
+  /**
+   * 添加枚举
+   * @internal
+   * @param enumerationOptions 枚举参数
+   */
+  _addEnum(enumerationOptions: Partial<Enum>): Enum;
+
+  /**
+   * 添加枚举
+   * @internal
+   * @param enumeration 已有的枚举实例
+   */
+  _addEnum(enumeration: Enum): Enum;
+
+  _addEnum(options?: string | Partial<Enum> | Enum) {
+    const index = 0;
+    return this._insertEnumAt(options as any, index);
+  }
+
+  /**
+   * 添加枚举
+   * @internal
+   * @param name 枚举名称，如果不填会自动生成一个唯一名称
+   */
+  addEnum(name?: string): Enum;
+
+  /**
+   * 添加枚举
+   * @param enumerationOptions 枚举参数
+   */
+  addEnum(enumerationOptions: Partial<Enum>): Enum;
+
+  /**
+   * 添加枚举
+   * @param enumeration 已有的枚举实例
+   */
+  addEnum(enumeration: Enum): Enum;
+
+  addEnum(options?: string | Partial<Enum> | Enum) {
+    const node = this._addEnum(options as any);
+    const index = this.enums.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'enums',
+    });
+    return node;
+  }
+
+  getLogicExistingNames(excludedList: Array<Logic> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getLogicUniqueName(name = 'logic1') {
+    return utils.unique(name, this.getLogicExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入逻辑
+   * @internal
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _insertLogicAt(name: string, index: number): Logic;
+
+  /**
+   * 插入逻辑
+   * @internal
+   * @param logicOptions 逻辑参数
+   */
+  _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+
+  /**
+   * 插入逻辑
+   * @internal
+   * @param logic 已有的逻辑实例
+   */
+  _insertLogicAt(logic: Logic, index: number): Logic;
+
+  _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+    const logicOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'logics' };
+    let logic: Logic;
+    if (!options) {
+      logic = Logic.from(
+        {
+          ...logicOptions,
+          name: this.getLogicUniqueName(),
+        },
+        this,
+        'logics'
+      );
+    } else if (typeof options === 'string') {
+      logic = Logic.from(
+        {
+          ...logicOptions,
+          name: options,
+        },
+        this,
+        'logics'
+      );
+    } else if (options instanceof Logic) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      logic = options;
+      Object.assign(logic, relationOptions);
+    } else {
+      logic = Logic.from(
+        {
+          ...logicOptions,
+          ...options,
+        },
+        this,
+        'logics'
+      );
+    }
+    this.logics.splice(index, 0, logic);
+    return logic;
+  }
+
+  /**
+   * 插入逻辑
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  insertLogicAt(name: string, index: number): Logic;
+
+  /**
+   * 插入逻辑
+   * @param logicOptions 逻辑参数
+   */
+  insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+
+  /**
+   * 插入逻辑
+   * @param logic 已有的逻辑实例
+   */
+  insertLogicAt(logic: Logic, index: number): Logic;
+
+  insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+    const node = this._insertLogicAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'logics',
+    });
+    return node;
+  }
+
+  /**
+   * 添加逻辑
+   * @internal
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _addLogic(name?: string): Logic;
+
+  /**
+   * 添加逻辑
+   * @internal
+   * @param logicOptions 逻辑参数
+   */
+  _addLogic(logicOptions: Partial<Logic>): Logic;
+
+  /**
+   * 添加逻辑
+   * @internal
+   * @param logic 已有的逻辑实例
+   */
+  _addLogic(logic: Logic): Logic;
+
+  _addLogic(options?: string | Partial<Logic> | Logic) {
+    const index = 0;
+    return this._insertLogicAt(options as any, index);
+  }
+
+  /**
+   * 添加逻辑
+   * @internal
+   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addLogic(name?: string): Logic;
+
+  /**
+   * 添加逻辑
+   * @param logicOptions 逻辑参数
+   */
+  addLogic(logicOptions: Partial<Logic>): Logic;
+
+  /**
+   * 添加逻辑
+   * @param logic 已有的逻辑实例
+   */
+  addLogic(logic: Logic): Logic;
+
+  addLogic(options?: string | Partial<Logic> | Logic) {
+    const node = this._addLogic(options as any);
+    const index = this.logics.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'logics',
+    });
+    return node;
+  }
+
+  getFunctionExistingNames(excludedList: Array<Function> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.functions as Function[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getFunctionUniqueName(name = 'func1') {
+    return utils.unique(name, this.getFunctionExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入函数
+   * @internal
+   * @param name 函数名称，如果不填会自动生成一个唯一名称
+   */
+  _insertFunctionAt(name: string, index: number): Function;
+
+  /**
+   * 插入函数
+   * @internal
+   * @param funcOptions 函数参数
+   */
+  _insertFunctionAt(funcOptions: Partial<Function>, index: number): Function;
+
+  /**
+   * 插入函数
+   * @internal
+   * @param func 已有的函数实例
+   */
+  _insertFunctionAt(func: Function, index: number): Function;
+
+  _insertFunctionAt(options: string | Partial<Function> | Function, index: number) {
+    const funcOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'functions' };
+    let func: Function;
+    if (!options) {
+      func = Function.from(
+        {
+          ...funcOptions,
+          name: this.getFunctionUniqueName(),
+        },
+        this,
+        'functions'
+      );
+    } else if (typeof options === 'string') {
+      func = Function.from(
+        {
+          ...funcOptions,
+          name: options,
+        },
+        this,
+        'functions'
+      );
+    } else if (options instanceof Function) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      func = options;
+      Object.assign(func, relationOptions);
+    } else {
+      func = Function.from(
+        {
+          ...funcOptions,
+          ...options,
+        },
+        this,
+        'functions'
+      );
+    }
+    this.functions.splice(index, 0, func);
+    return func;
+  }
+
+  /**
+   * 插入函数
+   * @param name 函数名称，如果不填会自动生成一个唯一名称
+   */
+  insertFunctionAt(name: string, index: number): Function;
+
+  /**
+   * 插入函数
+   * @param funcOptions 函数参数
+   */
+  insertFunctionAt(funcOptions: Partial<Function>, index: number): Function;
+
+  /**
+   * 插入函数
+   * @param func 已有的函数实例
+   */
+  insertFunctionAt(func: Function, index: number): Function;
+
+  insertFunctionAt(options: string | Partial<Function> | Function, index: number) {
+    const node = this._insertFunctionAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'functions',
+    });
+    return node;
+  }
+
+  /**
+   * 添加函数
+   * @internal
+   * @param name 函数名称，如果不填会自动生成一个唯一名称
+   */
+  _addFunction(name?: string): Function;
+
+  /**
+   * 添加函数
+   * @internal
+   * @param funcOptions 函数参数
+   */
+  _addFunction(funcOptions: Partial<Function>): Function;
+
+  /**
+   * 添加函数
+   * @internal
+   * @param func 已有的函数实例
+   */
+  _addFunction(func: Function): Function;
+
+  _addFunction(options?: string | Partial<Function> | Function) {
+    const index = 0;
+    return this._insertFunctionAt(options as any, index);
+  }
+
+  /**
+   * 添加函数
+   * @internal
+   * @param name 函数名称，如果不填会自动生成一个唯一名称
+   */
+  addFunction(name?: string): Function;
+
+  /**
+   * 添加函数
+   * @param funcOptions 函数参数
+   */
+  addFunction(funcOptions: Partial<Function>): Function;
+
+  /**
+   * 添加函数
+   * @param func 已有的函数实例
+   */
+  addFunction(func: Function): Function;
+
+  addFunction(options?: string | Partial<Function> | Function) {
+    const node = this._addFunction(options as any);
+    const index = this.functions.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'functions',
+    });
+    return node;
+  }
+
+  getInterfaceExistingNames(excludedList: Array<Interface> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getInterfaceUniqueName(name = 'Interface1') {
+    return utils.unique(name, this.getInterfaceExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入接口
+   * @internal
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  _insertInterfaceAt(name: string, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @internal
+   * @param itfaceOptions 接口参数
+   */
+  _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @internal
+   * @param itface 已有的接口实例
+   */
+  _insertInterfaceAt(itface: Interface, index: number): Interface;
+
+  _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+    const itfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+    let itface: Interface;
+    if (!options) {
+      itface = Interface.from(
+        {
+          ...itfaceOptions,
+          name: this.getInterfaceUniqueName(),
+        },
+        this,
+        'interfaces'
+      );
+    } else if (typeof options === 'string') {
+      itface = Interface.from(
+        {
+          ...itfaceOptions,
+          name: options,
+        },
+        this,
+        'interfaces'
+      );
+    } else if (options instanceof Interface) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      itface = options;
+      Object.assign(itface, relationOptions);
+    } else {
+      itface = Interface.from(
+        {
+          ...itfaceOptions,
+          ...options,
+        },
+        this,
+        'interfaces'
+      );
+    }
+    this.interfaces.splice(index, 0, itface);
+    return itface;
+  }
+
+  /**
+   * 插入接口
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  insertInterfaceAt(name: string, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @param itfaceOptions 接口参数
+   */
+  insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @param itface 已有的接口实例
+   */
+  insertInterfaceAt(itface: Interface, index: number): Interface;
+
+  insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+    const node = this._insertInterfaceAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'interfaces',
+    });
+    return node;
+  }
+
+  /**
+   * 添加接口
+   * @internal
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  _addInterface(name?: string): Interface;
+
+  /**
+   * 添加接口
+   * @internal
+   * @param itfaceOptions 接口参数
+   */
+  _addInterface(itfaceOptions: Partial<Interface>): Interface;
+
+  /**
+   * 添加接口
+   * @internal
+   * @param itface 已有的接口实例
+   */
+  _addInterface(itface: Interface): Interface;
+
+  _addInterface(options?: string | Partial<Interface> | Interface) {
+    const index = 0;
+    return this._insertInterfaceAt(options as any, index);
+  }
+
+  /**
+   * 添加接口
+   * @internal
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  addInterface(name?: string): Interface;
+
+  /**
+   * 添加接口
+   * @param itfaceOptions 接口参数
+   */
+  addInterface(itfaceOptions: Partial<Interface>): Interface;
+
+  /**
+   * 添加接口
+   * @param itface 已有的接口实例
+   */
+  addInterface(itface: Interface): Interface;
+
+  addInterface(options?: string | Partial<Interface> | Interface) {
+    const node = this._addInterface(options as any);
+    const index = this.interfaces.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'interfaces',
+    });
+    return node;
+  }
+
+  getViewExistingNames(excludedList: Array<View> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.views as View[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getViewUniqueName(name = 'view1') {
+    return utils.unique(name, this.getViewExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入页面
+   * @internal
+   * @param name 页面名称，如果不填会自动生成一个唯一名称
+   */
+  _insertViewAt(name: string, index: number): View;
+
+  /**
+   * 插入页面
+   * @internal
+   * @param viewOptions 页面参数
+   */
+  _insertViewAt(viewOptions: Partial<View>, index: number): View;
+
+  /**
+   * 插入页面
+   * @internal
+   * @param view 已有的页面实例
+   */
+  _insertViewAt(view: View, index: number): View;
+
+  _insertViewAt(options: string | Partial<View> | View, index: number) {
+    const viewOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'views' };
+    let view: View;
+    if (!options) {
+      view = View.from(
+        {
+          ...viewOptions,
+          name: this.getViewUniqueName(),
+        },
+        this,
+        'views'
+      );
+    } else if (typeof options === 'string') {
+      view = View.from(
+        {
+          ...viewOptions,
+          name: options,
+        },
+        this,
+        'views'
+      );
+    } else if (options instanceof View) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      view = options;
+      Object.assign(view, relationOptions);
+    } else {
+      view = View.from(
+        {
+          ...viewOptions,
+          ...options,
+        },
+        this,
+        'views'
+      );
+    }
+    this.views.splice(index, 0, view);
+    return view;
+  }
+
+  /**
+   * 插入页面
+   * @param name 页面名称，如果不填会自动生成一个唯一名称
+   */
+  insertViewAt(name: string, index: number): View;
+
+  /**
+   * 插入页面
+   * @param viewOptions 页面参数
+   */
+  insertViewAt(viewOptions: Partial<View>, index: number): View;
+
+  /**
+   * 插入页面
+   * @param view 已有的页面实例
+   */
+  insertViewAt(view: View, index: number): View;
+
+  insertViewAt(options: string | Partial<View> | View, index: number) {
+    const node = this._insertViewAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'views',
+    });
+    return node;
+  }
+
+  /**
+   * 添加页面
+   * @internal
+   * @param name 页面名称，如果不填会自动生成一个唯一名称
+   */
+  _addView(name?: string): View;
+
+  /**
+   * 添加页面
+   * @internal
+   * @param viewOptions 页面参数
+   */
+  _addView(viewOptions: Partial<View>): View;
+
+  /**
+   * 添加页面
+   * @internal
+   * @param view 已有的页面实例
+   */
+  _addView(view: View): View;
+
+  _addView(options?: string | Partial<View> | View) {
+    const index = this.views.length;
+    return this._insertViewAt(options as any, index);
+  }
+
+  /**
+   * 添加页面
+   * @internal
+   * @param name 页面名称，如果不填会自动生成一个唯一名称
+   */
+  addView(name?: string): View;
+
+  /**
+   * 添加页面
+   * @param viewOptions 页面参数
+   */
+  addView(viewOptions: Partial<View>): View;
+
+  /**
+   * 添加页面
+   * @param view 已有的页面实例
+   */
+  addView(view: View): View;
+
+  addView(options?: string | Partial<View> | View) {
+    const node = this._addView(options as any);
+    const index = this.views.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'views',
+    });
+    return node;
+  }
+
+  getVarExistingNames(excludedList: Array<Variable> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.frontendVariables as Variable[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getVariableUniqueName(name = 'variable1') {
+    return utils.unique(name, this.getVarExistingNames(), undefined, true);
+  }
+
+  /**
+   * 插入变量
+   * @internal
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  _insertVariableInFrontendVariablesAt(name: string, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @internal
+   * @param variableOptions 变量参数
+   */
+  _insertVariableInFrontendVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @internal
+   * @param variable 已有的变量实例
+   */
+  _insertVariableInFrontendVariablesAt(variable: Variable, index: number): Variable;
+
+  _insertVariableInFrontendVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
+    const variableOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'frontendVariables' };
+    let variable: Variable;
+    if (!options) {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          name: this.getVariableUniqueName(),
+        },
+        this,
+        'frontendVariables'
+      );
+    } else if (typeof options === 'string') {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          name: options,
+        },
+        this,
+        'frontendVariables'
+      );
+    } else if (options instanceof Variable) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      variable = options;
+      Object.assign(variable, relationOptions);
+    } else {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          ...options,
+        },
+        this,
+        'frontendVariables'
+      );
+    }
+    this.frontendVariables.splice(index, 0, variable);
+    return variable;
+  }
+
+  /**
+   * 插入变量
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  insertVariableInFrontendVariablesAt(name: string, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @param variableOptions 变量参数
+   */
+  insertVariableInFrontendVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @param variable 已有的变量实例
+   */
+  insertVariableInFrontendVariablesAt(variable: Variable, index: number): Variable;
+
+  insertVariableInFrontendVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
+    const node = this._insertVariableInFrontendVariablesAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'frontendVariables',
+    });
+    return node;
+  }
+
+  /**
+   * 添加变量
+   * @internal
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  _addVariableInFrontendVariables(name?: string): Variable;
+
+  /**
+   * 添加变量
+   * @internal
+   * @param variableOptions 变量参数
+   */
+  _addVariableInFrontendVariables(variableOptions: Partial<Variable>): Variable;
+
+  /**
+   * 添加变量
+   * @internal
+   * @param variable 已有的变量实例
+   */
+  _addVariableInFrontendVariables(variable: Variable): Variable;
+
+  _addVariableInFrontendVariables(options?: string | Partial<Variable> | Variable) {
+    const index = this.frontendVariables.length;
+    return this._insertVariableInFrontendVariablesAt(options as any, index);
+  }
+
+  /**
+   * 添加变量
+   * @internal
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  addVariableInFrontendVariables(name?: string): Variable;
+
+  /**
+   * 添加变量
+   * @param variableOptions 变量参数
+   */
+  addVariableInFrontendVariables(variableOptions: Partial<Variable>): Variable;
+
+  /**
+   * 添加变量
+   * @param variable 已有的变量实例
+   */
+  addVariableInFrontendVariables(variable: Variable): Variable;
+
+  addVariableInFrontendVariables(options?: string | Partial<Variable> | Variable) {
+    const node = this._addVariableInFrontendVariables(options as any);
+    const index = this.frontendVariables.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'frontendVariables',
+    });
+    return node;
+  }
+
+  /**
+   * 插入变量
+   * @internal
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  _insertVariableInVariablesAt(name: string, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @internal
+   * @param variableOptions 变量参数
+   */
+  _insertVariableInVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @internal
+   * @param variable 已有的变量实例
+   */
+  _insertVariableInVariablesAt(variable: Variable, index: number): Variable;
+
+  _insertVariableInVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
+    const variableOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'variables' };
+    let variable: Variable;
+    if (!options) {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          name: this.getVariableUniqueName(),
+        },
+        this,
+        'variables'
+      );
+    } else if (typeof options === 'string') {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          name: options,
+        },
+        this,
+        'variables'
+      );
+    } else if (options instanceof Variable) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      variable = options;
+      Object.assign(variable, relationOptions);
+    } else {
+      variable = Variable.from(
+        {
+          ...variableOptions,
+          ...options,
+        },
+        this,
+        'variables'
+      );
+    }
+    this.variables.splice(index, 0, variable);
+    return variable;
+  }
+
+  /**
+   * 插入变量
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  insertVariableInVariablesAt(name: string, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @param variableOptions 变量参数
+   */
+  insertVariableInVariablesAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+  /**
+   * 插入变量
+   * @param variable 已有的变量实例
+   */
+  insertVariableInVariablesAt(variable: Variable, index: number): Variable;
+
+  insertVariableInVariablesAt(options: string | Partial<Variable> | Variable, index: number) {
+    const node = this._insertVariableInVariablesAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'variables',
+    });
+    return node;
+  }
+
+  /**
+   * 添加变量
+   * @internal
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  _addVariableInVariables(name?: string): Variable;
+
+  /**
+   * 添加变量
+   * @internal
+   * @param variableOptions 变量参数
+   */
+  _addVariableInVariables(variableOptions: Partial<Variable>): Variable;
+
+  /**
+   * 添加变量
+   * @internal
+   * @param variable 已有的变量实例
+   */
+  _addVariableInVariables(variable: Variable): Variable;
+
+  _addVariableInVariables(options?: string | Partial<Variable> | Variable) {
+    const index = this.variables.length;
+    return this._insertVariableInVariablesAt(options as any, index);
+  }
+
+  /**
+   * 添加变量
+   * @internal
+   * @param name 变量名称，如果不填会自动生成一个唯一名称
+   */
+  addVariableInVariables(name?: string): Variable;
+
+  /**
+   * 添加变量
+   * @param variableOptions 变量参数
+   */
+  addVariableInVariables(variableOptions: Partial<Variable>): Variable;
+
+  /**
+   * 添加变量
+   * @param variable 已有的变量实例
+   */
+  addVariableInVariables(variable: Variable): Variable;
+
+  addVariableInVariables(options?: string | Partial<Variable> | Variable) {
+    const node = this._addVariableInVariables(options as any);
+    const index = this.variables.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'variables',
+    });
+    return node;
+  }
+
+  getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.viewComponents as ViewComponent[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getViewComponentUniqueName(name = 'viewComponent1') {
+    return utils.unique(name, this.getViewComponentExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入页面组件
+   * @internal
+   * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+   */
+  _insertViewComponentAt(name: string, index: number): ViewComponent;
+
+  /**
+   * 插入页面组件
+   * @internal
+   * @param viewComponentOptions 页面组件参数
+   */
+  _insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
+
+  /**
+   * 插入页面组件
+   * @internal
+   * @param viewComponent 已有的页面组件实例
+   */
+  _insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
+
+  _insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
+    const viewComponentOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'viewComponents' };
+    let viewComponent: ViewComponent;
+    if (!options) {
+      viewComponent = ViewComponent.from(
+        {
+          ...viewComponentOptions,
+          name: this.getViewComponentUniqueName(),
+        },
+        this,
+        'viewComponents'
+      );
+    } else if (typeof options === 'string') {
+      viewComponent = ViewComponent.from(
+        {
+          ...viewComponentOptions,
+          name: options,
+        },
+        this,
+        'viewComponents'
+      );
+    } else if (options instanceof ViewComponent) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      viewComponent = options;
+      Object.assign(viewComponent, relationOptions);
+    } else {
+      viewComponent = ViewComponent.from(
+        {
+          ...viewComponentOptions,
+          ...options,
+        },
+        this,
+        'viewComponents'
+      );
+    }
+    this.viewComponents.splice(index, 0, viewComponent);
+    return viewComponent;
+  }
+
+  /**
+   * 插入页面组件
+   * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+   */
+  insertViewComponentAt(name: string, index: number): ViewComponent;
+
+  /**
+   * 插入页面组件
+   * @param viewComponentOptions 页面组件参数
+   */
+  insertViewComponentAt(viewComponentOptions: Partial<ViewComponent>, index: number): ViewComponent;
+
+  /**
+   * 插入页面组件
+   * @param viewComponent 已有的页面组件实例
+   */
+  insertViewComponentAt(viewComponent: ViewComponent, index: number): ViewComponent;
+
+  insertViewComponentAt(options: string | Partial<ViewComponent> | ViewComponent, index: number) {
+    const node = this._insertViewComponentAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'viewComponents',
+    });
+    return node;
+  }
+
+  /**
+   * 添加页面组件
+   * @internal
+   * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+   */
+  _addViewComponent(name?: string): ViewComponent;
+
+  /**
+   * 添加页面组件
+   * @internal
+   * @param viewComponentOptions 页面组件参数
+   */
+  _addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
+
+  /**
+   * 添加页面组件
+   * @internal
+   * @param viewComponent 已有的页面组件实例
+   */
+  _addViewComponent(viewComponent: ViewComponent): ViewComponent;
+
+  _addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
+    const index = this.viewComponents.length;
+    return this._insertViewComponentAt(options as any, index);
+  }
+
+  /**
+   * 添加页面组件
+   * @internal
+   * @param name 页面组件名称，如果不填会自动生成一个唯一名称
+   */
+  addViewComponent(name?: string): ViewComponent;
+
+  /**
+   * 添加页面组件
+   * @param viewComponentOptions 页面组件参数
+   */
+  addViewComponent(viewComponentOptions: Partial<ViewComponent>): ViewComponent;
+
+  /**
+   * 添加页面组件
+   * @param viewComponent 已有的页面组件实例
+   */
+  addViewComponent(viewComponent: ViewComponent): ViewComponent;
+
+  addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
+    const node = this._addViewComponent(options as any);
+    const index = this.viewComponents.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'viewComponents',
+    });
+    return node;
+  }
+
+  getProcessComponentExistingNames(excludedList: Array<ProcessComponent> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.processComponents as ProcessComponent[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getProcessComponentUniqueName(name = 'processComponent1') {
+    return utils.unique(name, this.getProcessComponentExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入流程组件
+   * @internal
+   * @param name 流程组件名称，如果不填会自动生成一个唯一名称
+   */
+  _insertProcessComponentAt(name: string, index: number): ProcessComponent;
+
+  /**
+   * 插入流程组件
+   * @internal
+   * @param processComponentOptions 流程组件参数
+   */
+  _insertProcessComponentAt(processComponentOptions: Partial<ProcessComponent>, index: number): ProcessComponent;
+
+  /**
+   * 插入流程组件
+   * @internal
+   * @param processComponent 已有的流程组件实例
+   */
+  _insertProcessComponentAt(processComponent: ProcessComponent, index: number): ProcessComponent;
+
+  _insertProcessComponentAt(options: string | Partial<ProcessComponent> | ProcessComponent, index: number) {
+    const processComponentOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'processComponents' };
+    let processComponent: ProcessComponent;
+    if (!options) {
+      processComponent = ProcessComponent.from(
+        {
+          ...processComponentOptions,
+          name: this.getProcessComponentUniqueName(),
+        },
+        this,
+        'processComponents'
+      );
+    } else if (typeof options === 'string') {
+      processComponent = ProcessComponent.from(
+        {
+          ...processComponentOptions,
+          name: options,
+        },
+        this,
+        'processComponents'
+      );
+    } else if (options instanceof ProcessComponent) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      processComponent = options;
+      Object.assign(processComponent, relationOptions);
+    } else {
+      processComponent = ProcessComponent.from(
+        {
+          ...processComponentOptions,
+          ...options,
+        },
+        this,
+        'processComponents'
+      );
+    }
+    this.processComponents.splice(index, 0, processComponent);
+    return processComponent;
+  }
+
+  /**
+   * 插入流程组件
+   * @param name 流程组件名称，如果不填会自动生成一个唯一名称
+   */
+  insertProcessComponentAt(name: string, index: number): ProcessComponent;
+
+  /**
+   * 插入流程组件
+   * @param processComponentOptions 流程组件参数
+   */
+  insertProcessComponentAt(processComponentOptions: Partial<ProcessComponent>, index: number): ProcessComponent;
+
+  /**
+   * 插入流程组件
+   * @param processComponent 已有的流程组件实例
+   */
+  insertProcessComponentAt(processComponent: ProcessComponent, index: number): ProcessComponent;
+
+  insertProcessComponentAt(options: string | Partial<ProcessComponent> | ProcessComponent, index: number) {
+    const node = this._insertProcessComponentAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'processComponents',
+    });
+    return node;
+  }
+
+  /**
+   * 添加流程组件
+   * @internal
+   * @param name 流程组件名称，如果不填会自动生成一个唯一名称
+   */
+  _addProcessComponent(name?: string): ProcessComponent;
+
+  /**
+   * 添加流程组件
+   * @internal
+   * @param processComponentOptions 流程组件参数
+   */
+  _addProcessComponent(processComponentOptions: Partial<ProcessComponent>): ProcessComponent;
+
+  /**
+   * 添加流程组件
+   * @internal
+   * @param processComponent 已有的流程组件实例
+   */
+  _addProcessComponent(processComponent: ProcessComponent): ProcessComponent;
+
+  _addProcessComponent(options?: string | Partial<ProcessComponent> | ProcessComponent) {
+    const index = this.processComponents.length;
+    return this._insertProcessComponentAt(options as any, index);
+  }
+
+  /**
+   * 添加流程组件
+   * @internal
+   * @param name 流程组件名称，如果不填会自动生成一个唯一名称
+   */
+  addProcessComponent(name?: string): ProcessComponent;
+
+  /**
+   * 添加流程组件
+   * @param processComponentOptions 流程组件参数
+   */
+  addProcessComponent(processComponentOptions: Partial<ProcessComponent>): ProcessComponent;
+
+  /**
+   * 添加流程组件
+   * @param processComponent 已有的流程组件实例
+   */
+  addProcessComponent(processComponent: ProcessComponent): ProcessComponent;
+
+  addProcessComponent(options?: string | Partial<ProcessComponent> | ProcessComponent) {
+    const node = this._addProcessComponent(options as any);
+    const index = this.processComponents.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'processComponents',
+    });
+    return node;
+  }
+
+  /**
+   * 删除命名空间
+   * @param name 命名空间名称
+   */
+  removeNamespace(name: string): void;
+
+  /**
+   * 删除命名空间
+   * @param namespace 已有的命名空间实例
+   */
+  removeNamespace(namespace: Namespace): void;
+
+  removeNamespace(options: string | Namespace) {
+    let namespace: Namespace;
+    if (typeof options === 'string') {
+      namespace = (this.children as Namespace[]).find((item) => item.name === options);
+      if (!namespace) {
+        throw new Error(`找不到命名空间 ${options}`);
+      }
+    } else {
+      namespace = options;
+    }
+    return namespace.delete();
+  }
+
+  __removeNamespace(namespace: Namespace) {
+    const { parentKey } = namespace;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: namespace,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(namespace);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === namespace) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除流程
+   * @param name 流程名称
+   */
+  removeProcess(name: string): void;
+
+  /**
+   * 删除流程
+   * @param process 已有的流程实例
+   */
+  removeProcess(process: Process): void;
+
+  removeProcess(options: string | Process) {
+    let process: Process;
+    if (typeof options === 'string') {
+      process = (this.processes as Process[]).find((item) => item.name === options);
+      if (!process) {
+        throw new Error(`找不到流程 ${options}`);
+      }
+    } else {
+      process = options;
+    }
+    return process.delete();
+  }
+
+  __removeProcess(process: Process) {
+    const { parentKey } = process;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: process,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(process);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === process) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除数据结构
+   * @param name 数据结构名称
+   */
+  removeStructure(name: string): void;
+
+  /**
+   * 删除数据结构
+   * @param structure 已有的数据结构实例
+   */
+  removeStructure(structure: Structure): void;
+
+  removeStructure(options: string | Structure) {
+    let structure: Structure;
+    if (typeof options === 'string') {
+      structure = (this.structures as Structure[]).find((item) => item.name === options);
+      if (!structure) {
+        throw new Error(`找不到数据结构 ${options}`);
+      }
+    } else {
+      structure = options;
+    }
+    return structure.delete();
+  }
+
+  __removeStructure(structure: Structure) {
+    const { parentKey } = structure;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: structure,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(structure);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === structure) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除枚举
+   * @param name 枚举名称
+   */
+  removeEnum(name: string): void;
+
+  /**
+   * 删除枚举
+   * @param enumeration 已有的枚举实例
+   */
+  removeEnum(enumeration: Enum): void;
+
+  removeEnum(options: string | Enum) {
+    let enumeration: Enum;
+    if (typeof options === 'string') {
+      enumeration = (this.enums as Enum[]).find((item) => item.name === options);
+      if (!enumeration) {
+        throw new Error(`找不到枚举 ${options}`);
+      }
+    } else {
+      enumeration = options;
+    }
+    return enumeration.delete();
+  }
+
+  __removeEnum(enumeration: Enum) {
+    const { parentKey } = enumeration;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: enumeration,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(enumeration);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === enumeration) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除逻辑
+   * @param name 逻辑名称
+   */
+  removeLogic(name: string): void;
+
+  /**
+   * 删除逻辑
+   * @param logic 已有的逻辑实例
+   */
+  removeLogic(logic: Logic): void;
+
+  removeLogic(options: string | Logic) {
+    let logic: Logic;
+    if (typeof options === 'string') {
+      logic = (this.logics as Logic[]).find((item) => item.name === options);
+      if (!logic) {
+        throw new Error(`找不到逻辑 ${options}`);
+      }
+    } else {
+      logic = options;
+    }
+    return logic.delete();
+  }
+
+  __removeLogic(logic: Logic) {
+    const { parentKey } = logic;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: logic,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(logic);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === logic) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除函数
+   * @param name 函数名称
+   */
+  removeFunction(name: string): void;
+
+  /**
+   * 删除函数
+   * @param func 已有的函数实例
+   */
+  removeFunction(func: Function): void;
+
+  removeFunction(options: string | Function) {
+    let func: Function;
+    if (typeof options === 'string') {
+      func = (this.functions as Function[]).find((item) => item.name === options);
+      if (!func) {
+        throw new Error(`找不到函数 ${options}`);
+      }
+    } else {
+      func = options;
+    }
+    return func.delete();
+  }
+
+  __removeFunction(func: Function) {
+    const { parentKey } = func;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: func,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(func);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === func) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除接口
+   * @param name 接口名称
+   */
+  removeInterface(name: string): void;
+
+  /**
+   * 删除接口
+   * @param itface 已有的接口实例
+   */
+  removeInterface(itface: Interface): void;
+
+  removeInterface(options: string | Interface) {
+    let itface: Interface;
+    if (typeof options === 'string') {
+      itface = (this.interfaces as Interface[]).find((item) => item.name === options);
+      if (!itface) {
+        throw new Error(`找不到接口 ${options}`);
+      }
+    } else {
+      itface = options;
+    }
+    return itface.delete();
+  }
+
+  __removeInterface(itface: Interface) {
+    const { parentKey } = itface;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: itface,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(itface);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === itface) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除页面
+   * @param name 页面名称
+   */
+  removeView(name: string): void;
+
+  /**
+   * 删除页面
+   * @param view 已有的页面实例
+   */
+  removeView(view: View): void;
+
+  removeView(options: string | View) {
+    let view: View;
+    if (typeof options === 'string') {
+      view = (this.views as View[]).find((item) => item.name === options);
+      if (!view) {
+        throw new Error(`找不到页面 ${options}`);
+      }
+    } else {
+      view = options;
+    }
+    return view.delete();
+  }
+
+  __removeView(view: View) {
+    const { parentKey } = view;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: view,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(view);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === view) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除变量
+   * @param name 变量名称
+   */
+  removeVariableInFrontendVariables(name: string): void;
+
+  /**
+   * 删除变量
+   * @param variable 已有的变量实例
+   */
+  removeVariableInFrontendVariables(variable: Variable): void;
+
+  removeVariableInFrontendVariables(options: string | Variable) {
+    let variable: Variable;
+    if (typeof options === 'string') {
+      variable = (this.frontendVariables as Variable[]).find((item) => item.name === options);
+      if (!variable) {
+        throw new Error(`找不到变量 ${options}`);
+      }
+    } else {
+      variable = options;
+    }
+    return variable.delete();
+  }
+
+  /**
+   * 删除变量
+   * @param name 变量名称
+   */
+  removeVariableInVariables(name: string): void;
+
+  /**
+   * 删除变量
+   * @param variable 已有的变量实例
+   */
+  removeVariableInVariables(variable: Variable): void;
+
+  removeVariableInVariables(options: string | Variable) {
+    let variable: Variable;
+    if (typeof options === 'string') {
+      variable = (this.variables as Variable[]).find((item) => item.name === options);
+      if (!variable) {
+        throw new Error(`找不到变量 ${options}`);
+      }
+    } else {
+      variable = options;
+    }
+    return variable.delete();
+  }
+
+  __removeVariable(variable: Variable) {
+    const { parentKey } = variable;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: variable,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(variable);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === variable) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除页面组件
+   * @param name 页面组件名称
+   */
+  removeViewComponent(name: string): void;
+
+  /**
+   * 删除页面组件
+   * @param viewComponent 已有的页面组件实例
+   */
+  removeViewComponent(viewComponent: ViewComponent): void;
+
+  removeViewComponent(options: string | ViewComponent) {
+    let viewComponent: ViewComponent;
+    if (typeof options === 'string') {
+      viewComponent = (this.viewComponents as ViewComponent[]).find((item) => item.name === options);
+      if (!viewComponent) {
+        throw new Error(`找不到页面组件 ${options}`);
+      }
+    } else {
+      viewComponent = options;
+    }
+    return viewComponent.delete();
+  }
+
+  __removeViewComponent(viewComponent: ViewComponent) {
+    const { parentKey } = viewComponent;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: viewComponent,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(viewComponent);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === viewComponent) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除流程组件
+   * @param name 流程组件名称
+   */
+  removeProcessComponent(name: string): void;
+
+  /**
+   * 删除流程组件
+   * @param processComponent 已有的流程组件实例
+   */
+  removeProcessComponent(processComponent: ProcessComponent): void;
+
+  removeProcessComponent(options: string | ProcessComponent) {
+    let processComponent: ProcessComponent;
+    if (typeof options === 'string') {
+      processComponent = (this.processComponents as ProcessComponent[]).find((item) => item.name === options);
+      if (!processComponent) {
+        throw new Error(`找不到流程组件 ${options}`);
+      }
+    } else {
+      processComponent = options;
+    }
+    return processComponent.delete();
+  }
+
+  __removeProcessComponent(processComponent: ProcessComponent) {
+    const { parentKey } = processComponent;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: processComponent,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(processComponent);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === processComponent) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+
+  findEnumByName(name: string) {
+    return this.enums.find((enumItem) => enumItem.name === name);
+  }
+
+  findStructureByName(name: string) {
+    return this.structures.find((item) => item.name === name);
+  }
+
+  findLogicByName(name: string) {
+    return this.logics.find((logic) => logic.name === name);
+  }
+
+  @property()
+  path: string = undefined;
+
+  /**
+   * 获取命名空间
+   */
+  getNamespace(): string {
+    if (this.path) return this.path;
+    if (this.parentNode && (this.parentNode as Namespace).getNamespace) return `${(this.parentNode as Namespace).getNamespace()}`;
+    throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
+  }
+
+  /**
+   * 获取命名空间
+   */
+  getTsNamespace(): string {
+    if (this.path) return this.path;
+    if (this.parentNode && (this.parentNode as Namespace).getNamespace) return `${(this.parentNode as Namespace).getNamespace()}.${this.tsName}`;
+    throw new Error('无法获取命名空间，请设置 parentNode 或临时的 path！');
+  }
+
+  findChild(name: string) {
+    return this.children.find((child) => child.name === name);
+  }
+
+  findLogic(name: string) {
+    return this.logics.find((logic) => logic.name === name);
+  }
+
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.Namespace = Namespace;
 export default Namespace;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================