@lcap/nasl 0.3.14 → 1.0.0-alpha.1

package/src/concepts/Namespace__.ts

@@ -0,0 +1,2517 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import Process from './Process__';
+import Entity from './Entity__';
+import Structure from './Structure__';
+import Enum from './Enum__';
+import Logic from './Logic__';
+import Function from './Function__';
+import Interface from './Interface__';
+import View from './View__';
+import Variable from './Variable__';
+import ViewComponent from './ViewComponent__';
+import ProcessComponent from './ProcessComponent__';
+
+/**
+ * 命名空间
+ */
+@concept
+export class Namespace extends BaseNode {
+    /**
+     * 产品概念
+     */
+    @property()
+    concept: 'Namespace' = 'Namespace';
+
+    /**
+     * 表示是从实体还是流程等概念产生的
+     */
+    @property()
+    originConcept: 'Namespace' = 'Namespace';
+
+    /**
+     * 命名空间名称
+     */
+    @property()
+    name: string = undefined;
+
+    /**
+     * 命名空间标题
+     */
+    @property()
+    title: string = undefined;
+
+    /**
+     * 命名空间描述
+     */
+    @property()
+    description: string = undefined;
+
+    /**
+     * 命名空间列表
+     */
+    @property('Namespace')
+    children: Array<Namespace> = [];
+
+    /**
+     * 流程列表
+     */
+    @property('Process')
+    processes: Array<Process> = [];
+
+    /**
+     * 实体列表
+     */
+    @property('Entity')
+    entities: Array<Entity> = [];
+
+    /**
+     * 数据结构列表
+     */
+    @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')
+    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);
+    }
+
+    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.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getNamespaceUniqueName(name = 'namespace1') {
+        return utils.unique(name, this.getNamespaceExistingNames());
+    }
+
+    /**
+    * 插入命名空间
+    * @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);
+        } else if (typeof options === 'string') {
+            namespace = Namespace.from({
+                ...namespaceOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Namespace) {
+            options.delete(); // 同一实例不支持多处存在
+            namespace = options;
+        } else {
+            namespace = Namespace.from({
+                ...namespaceOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(namespace, relationOptions);
+        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.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'children',
+        });
+        return node;
+    }
+
+
+    getProcessExistingNames(excludedList: Array<Process> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.processes.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getProcessUniqueName(name = 'Process1') {
+        return utils.unique(name, this.getProcessExistingNames());
+    }
+
+    /**
+    * 插入流程
+    * @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);
+        } else if (typeof options === 'string') {
+            process = Process.from({
+                ...processOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Process) {
+            options.delete(); // 同一实例不支持多处存在
+            process = options;
+        } else {
+            process = Process.from({
+                ...processOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(process, relationOptions);
+        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 = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+
+
+    getEntityExistingNames(excludedList: Array<Entity> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.entities.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getEntityUniqueName(name = 'Entity1') {
+        return utils.unique(name, this.getEntityExistingNames());
+    }
+
+    /**
+    * 插入实体
+    * @internal
+    * @param name 实体名称，如果不填会自动生成一个唯一名称
+    */
+    _insertEntityAt(name: string, index: number): Entity;
+
+    /**
+    * 插入实体
+    * @internal
+    * @param entityOptions 实体参数
+    */
+    _insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
+
+    /**
+    * 插入实体
+    * @internal
+    * @param entity 已有的实体实例
+    */
+    _insertEntityAt(entity: Entity, index: number): Entity;
+
+    _insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
+        const entityOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'entities' };
+        let entity: Entity;
+        if (!options) {
+            entity = Entity.from({
+                ...entityOptions,
+                name: this.getEntityUniqueName(),
+            }, this);
+        } else if (typeof options === 'string') {
+            entity = Entity.from({
+                ...entityOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Entity) {
+            options.delete(); // 同一实例不支持多处存在
+            entity = options;
+        } else {
+            entity = Entity.from({
+                ...entityOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(entity, relationOptions);
+        this.entities.splice(index, 0, entity);
+        return entity;
+    }
+
+    /**
+     * 插入实体
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    insertEntityAt(name: string, index: number): Entity;
+
+    /**
+     * 插入实体
+     * @param entityOptions 实体参数
+     */
+    insertEntityAt(entityOptions: Partial<Entity>, index: number): Entity;
+
+    /**
+     * 插入实体
+     * @param entity 已有的实体实例
+     */
+    insertEntityAt(entity: Entity, index: number): Entity;
+
+    insertEntityAt(options: string | Partial<Entity> | Entity, index: number) {
+        const node = this._insertEntityAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'entities',
+        });
+        return node;
+    }
+
+    /**
+     * 添加实体
+     * @internal
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    _addEntity(name?: string): Entity;
+
+    /**
+     * 添加实体
+     * @internal
+     * @param entityOptions 实体参数
+     */
+    _addEntity(entityOptions: Partial<Entity>): Entity;
+
+    /**
+     * 添加实体
+     * @internal
+     * @param entity 已有的实体实例
+     */
+    _addEntity(entity: Entity): Entity;
+
+    _addEntity(options?: string | Partial<Entity> | Entity) {
+        const index = 0;
+        return this._insertEntityAt(options as any, index);
+    }
+
+    /**
+     * 添加实体
+     * @internal
+     * @param name 实体名称，如果不填会自动生成一个唯一名称
+     */
+    addEntity(name?: string): Entity;
+
+    /**
+     * 添加实体
+     * @param entityOptions 实体参数
+     */
+    addEntity(entityOptions: Partial<Entity>): Entity;
+
+    /**
+     * 添加实体
+     * @param entity 已有的实体实例
+     */
+    addEntity(entity: Entity): Entity;
+
+    addEntity(options?: string | Partial<Entity> | Entity) {
+        const node = this._addEntity(options as any);
+        const index = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'entities',
+        });
+        return node;
+    }
+
+
+    getStructureExistingNames(excludedList: Array<Structure> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.structures.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getStructureUniqueName(name = 'Structure1') {
+        return utils.unique(name, this.getStructureExistingNames());
+    }
+
+    /**
+    * 插入数据结构
+    * @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);
+        } else if (typeof options === 'string') {
+            structure = Structure.from({
+                ...structureOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Structure) {
+            options.delete(); // 同一实例不支持多处存在
+            structure = options;
+        } else {
+            structure = Structure.from({
+                ...structureOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(structure, relationOptions);
+        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 = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+
+
+    getEnumExistingNames(excludedList: Array<Enum> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.enums.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getEnumUniqueName(name = 'Enum1') {
+        return utils.unique(name, this.getEnumExistingNames());
+    }
+
+    /**
+    * 插入枚举
+    * @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);
+        } else if (typeof options === 'string') {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Enum) {
+            options.delete(); // 同一实例不支持多处存在
+            enumeration = options;
+        } else {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(enumeration, relationOptions);
+        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 = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+
+
+    getLogicExistingNames(excludedList: Array<Logic> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.logics.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getLogicUniqueName(name = 'logic1') {
+        return utils.unique(name, this.getLogicExistingNames());
+    }
+
+    /**
+    * 插入逻辑
+    * @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);
+        } else if (typeof options === 'string') {
+            logic = Logic.from({
+                ...logicOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Logic) {
+            options.delete(); // 同一实例不支持多处存在
+            logic = options;
+        } else {
+            logic = Logic.from({
+                ...logicOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(logic, relationOptions);
+        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 = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+
+
+    getFunctionExistingNames(excludedList: Array<Function> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.functions.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getFunctionUniqueName(name = 'func1') {
+        return utils.unique(name, this.getFunctionExistingNames());
+    }
+
+    /**
+    * 插入函数
+    * @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);
+        } else if (typeof options === 'string') {
+            func = Function.from({
+                ...funcOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Function) {
+            options.delete(); // 同一实例不支持多处存在
+            func = options;
+        } else {
+            func = Function.from({
+                ...funcOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(func, relationOptions);
+        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 = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'functions',
+        });
+        return node;
+    }
+
+
+    getInterfaceExistingNames(excludedList: Array<Interface> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.interfaces.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getInterfaceUniqueName(name = 'Interface1') {
+        return utils.unique(name, this.getInterfaceExistingNames());
+    }
+
+    /**
+    * 插入接口
+    * @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);
+        } else if (typeof options === 'string') {
+            itface = Interface.from({
+                ...itfaceOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Interface) {
+            options.delete(); // 同一实例不支持多处存在
+            itface = options;
+        } else {
+            itface = Interface.from({
+                ...itfaceOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(itface, relationOptions);
+        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 = 0;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+
+
+    getViewExistingNames(excludedList: Array<View> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.views.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewUniqueName(name = 'view1') {
+        return utils.unique(name, this.getViewExistingNames());
+    }
+
+    /**
+    * 插入页面
+    * @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);
+        } else if (typeof options === 'string') {
+            view = View.from({
+                ...viewOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof View) {
+            options.delete(); // 同一实例不支持多处存在
+            view = options;
+        } else {
+            view = View.from({
+                ...viewOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(view, relationOptions);
+        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.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+
+
+    getVariableExistingNames(excludedList: Array<Variable> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.variables.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getVariableUniqueName(name = 'variable1') {
+        return utils.unique(name, this.getVariableExistingNames());
+    }
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+    */
+    _insertVariableAt(name: string, index: number): Variable;
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param variableOptions 局部变量参数
+    */
+    _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+    /**
+    * 插入局部变量
+    * @internal
+    * @param variable 已有的局部变量实例
+    */
+    _insertVariableAt(variable: Variable, index: number): Variable;
+
+    _insertVariableAt(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);
+        } else if (typeof options === 'string') {
+            variable = Variable.from({
+                ...variableOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof Variable) {
+            options.delete(); // 同一实例不支持多处存在
+            variable = options;
+        } else {
+            variable = Variable.from({
+                ...variableOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(variable, relationOptions);
+        this.variables.splice(index, 0, variable);
+        return variable;
+    }
+
+    /**
+     * 插入局部变量
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    insertVariableAt(name: string, index: number): Variable;
+
+    /**
+     * 插入局部变量
+     * @param variableOptions 局部变量参数
+     */
+    insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+
+    /**
+     * 插入局部变量
+     * @param variable 已有的局部变量实例
+     */
+    insertVariableAt(variable: Variable, index: number): Variable;
+
+    insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
+        const node = this._insertVariableAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    _addVariable(name?: string): Variable;
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param variableOptions 局部变量参数
+     */
+    _addVariable(variableOptions: Partial<Variable>): Variable;
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param variable 已有的局部变量实例
+     */
+    _addVariable(variable: Variable): Variable;
+
+    _addVariable(options?: string | Partial<Variable> | Variable) {
+        const index = this.variables.length;
+        return this._insertVariableAt(options as any, index);
+    }
+
+    /**
+     * 添加局部变量
+     * @internal
+     * @param name 局部变量名称，如果不填会自动生成一个唯一名称
+     */
+    addVariable(name?: string): Variable;
+
+    /**
+     * 添加局部变量
+     * @param variableOptions 局部变量参数
+     */
+    addVariable(variableOptions: Partial<Variable>): Variable;
+
+    /**
+     * 添加局部变量
+     * @param variable 已有的局部变量实例
+     */
+    addVariable(variable: Variable): Variable;
+
+    addVariable(options?: string | Partial<Variable> | Variable) {
+        const node = this._addVariable(options as any);
+        const index = this.variables.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'variables',
+        });
+        return node;
+    }
+
+
+    getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.viewComponents.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewComponentUniqueName(name = 'viewComponent1') {
+        return utils.unique(name, this.getViewComponentExistingNames());
+    }
+
+    /**
+    * 插入页面组件
+    * @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);
+        } else if (typeof options === 'string') {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof ViewComponent) {
+            options.delete(); // 同一实例不支持多处存在
+            viewComponent = options;
+        } else {
+            viewComponent = ViewComponent.from({
+                ...viewComponentOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(viewComponent, relationOptions);
+        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.length;
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'viewComponents',
+        });
+        return node;
+    }
+
+
+    getProcessComponentExistingNames(excludedList: Array<ProcessComponent> = []) {
+        const excludedSet = new Set(excludedList);
+        return this.processComponents.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getProcessComponentUniqueName(name = 'processComponent1') {
+        return utils.unique(name, this.getProcessComponentExistingNames());
+    }
+
+    /**
+    * 插入流程组件
+    * @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);
+        } else if (typeof options === 'string') {
+            processComponent = ProcessComponent.from({
+                ...processComponentOptions,
+                name: options,
+            }, this);
+        } else if (options instanceof ProcessComponent) {
+            options.delete(); // 同一实例不支持多处存在
+            processComponent = options;
+        } else {
+            processComponent = ProcessComponent.from({
+                ...processComponentOptions,
+                ...options,
+            }, this);
+        }
+        Object.assign(processComponent, relationOptions);
+        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.length;
+        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.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.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 实体名称
+    */
+    removeEntity(name: string): void;
+
+    /**
+     * 删除实体
+     * @param entity 已有的实体实例
+     */
+    removeEntity(entity: Entity): void;
+
+    removeEntity(options: string | Entity) {
+        let entity: Entity;
+        if (typeof options === 'string') {
+            entity = this.entities.find((item) => item.name === options);
+            if (!entity) {
+                throw new Error('找不到实体 ' + options);
+            }
+        } else {
+            entity = options;
+        }
+        return entity.delete();
+    }
+
+    __removeEntity(entity: Entity) {
+        const parentKey = entity.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: entity,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(entity);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === entity) {
+                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.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.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.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.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.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.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 局部变量名称
+    */
+    removeVariable(name: string): void;
+
+    /**
+     * 删除局部变量
+     * @param variable 已有的局部变量实例
+     */
+    removeVariable(variable: Variable): void;
+
+    removeVariable(options: string | Variable) {
+        let variable: Variable;
+        if (typeof options === 'string') {
+            variable = this.variables.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.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.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;
+    }
+
+    //================================================================================
+    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+    // 自动生成的代码已结束。下面可以手动编写。
+    //================================================================================
+
+    findEntityByName(name: string) {
+        return this.entities.find((entity) => entity.name === name);
+    }
+
+    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()}.${this.name}`;
+        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 自动生成，请不手动修改！
+    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+    //================================================================================
+}
+
+classMap['Namespace'] = Namespace;
+export default Namespace;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================