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

package/src/concepts/Module__.ts

@@ -1,20 +1,13 @@
-type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
-const moduleNameSpace = {
-    dependencies: 'extensions',
-    interfaceDependencies: 'apis',
-    componentDependencies: 'components',
-};
-type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies';
+import { v4 as uuidv4 } from 'uuid';
 import ConfigProperty from './ConfigProperty__';
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 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 DataSource from './DataSource__';
@@ -28,2287 +21,2606 @@ import Process from './Process__';
 import FrontendLibrary from './FrontendLibrary__';
 import Configuration from './Configuration__';
 import TriggerLauncher from './TriggerLauncher__';
+import Connection from './Connection__';
 import App from './App__';
 
+type PropertyType = 'structures' | 'enums' | 'entities' | 'interfaces' | 'processes' | 'views';
+const moduleNameSpace = {
+  dependencies: 'extensions',
+  interfaceDependencies: 'apis',
+  componentDependencies: 'components',
+};
+type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies';
+
 /**
  * 模块
  */
 @concept('模块')
 export class Module extends BaseNode {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'Module' | 'Connector' = 'Module';
-
-    /**
-     * type
-     */
-    @property()
-    type: 'extension' | 'interface' | 'component' | 'connector' = undefined;
-
-    /**
-     * version
-     */
-    @property()
-    version: string = undefined;
-
-    /**
-     * 模块名称
-     */
-    @property()
-    name: string = undefined;
-
-    /**
-     * 模块标题
-     */
-    @property()
-    title: string = undefined;
-
-    /**
-     * 模块描述
-     */
-    @property()
-    description: string = undefined;
-
-    /**
-     * provider
-     */
-    @property()
-    provider: string = undefined;
-
-    /**
-     * 外部语言依赖
-     */
-    @property()
-    externalDependencyMap: { maven?: Array<{ groupId: string, artifactId: string, version: string }> } = undefined;
-
-    /**
-     * 外部语言依赖
-     */
-    @property()
-    compilerInfoMap: {
-            java?: Array<{ packageName: string, className: string, naslName: string, type: string, javaTypes: any }>,
-            js?: { packageName : string,prefix:string },
-    } = undefined;
-
-    /**
-     * 数据源列表
-     */
-    @property('DataSource')
-    dataSources: Array<DataSource> = [];
-
-    /**
-     * 数据结构列表
-     */
-    @property('Structure')
-    structures: Array<Structure> = [];
-
-    /**
-     * 枚举列表
-     */
-    @property('Enum')
-    enums: Array<Enum> = [];
-
-    /**
-     * 逻辑列表
-     */
-    @property('Logic')
-    logics: Array<Logic> = [];
-
-    /**
-     * 接口列表
-     */
-    @property('Interface')
-    interfaces: Array<Interface> = [];
-
-    /**
-     * 页面列表
-     */
-    @property('View')
-    views: Array<View> = [];
-
-    /**
-     * 变量列表
-     */
-    @property('Variable')
-    frontendVariables: Array<Variable> = [];
-
-    /**
-     * 流程列表
-     */
-    @property('Process')
-    processes: Array<Process> = [];
-
-    /**
-     * 端包列表
-     */
-    @property('FrontendLibrary')
-    frontends: Array<FrontendLibrary> = [];
-
-    /**
-     * 配置管理
-     */
-    @property('Configuration')
-    configuration: Configuration = undefined;
-
-    /**
-     * 触发器启动器列表
-     */
-    @property('TriggerLauncher')
-    triggerLaunchers: Array<TriggerLauncher> = [];
-
-    /**
-     * 祖先 App
-     */
-    get app() {
-        return this.getAncestor('App') as App;
-    }
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<Module>) {
-        source = Object.assign({}, Module.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
-    }
-    getClassName() {
-        return 'Module';
-    }
-
-    static from(source: any, parentNode?: any, parentKey?: string): Module {
-        return super.from(source, parentNode, parentKey) as Module;
-    }
-
-    /**
-     * 从父级删除该节点
-     * @internal
-     */
-    _delete() {
-        let params: Params = null;
-        if (this.parentNode) {
-            params = (this.parentNode as any)?.__removeModule?.(this);
-        }
-        return params;
-    }
-    
-
-        getDataSourceExistingNames(excludedList: Array<DataSource> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.dataSources as DataSource[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getDataSourceUniqueName(name = 'dataSource1') {
-        return utils.unique(name, this.getDataSourceExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入数据源
-    * @internal
-    * @param name 数据源名称，如果不填会自动生成一个唯一名称
-    */
-    _insertDataSourceAt(name: string, index: number): DataSource;
-
-    /**
-    * 插入数据源
-    * @internal
-    * @param dataSourceOptions 数据源参数
-    */
-    _insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
-
-    /**
-    * 插入数据源
-    * @internal
-    * @param dataSource 已有的数据源实例
-    */
-    _insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
-
-    _insertDataSourceAt(options: string | Partial<DataSource> | DataSource, index: number) {
-        const dataSourceOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'dataSources' };
-        let dataSource: DataSource;
-        if (!options) {
-            dataSource = DataSource.from({
-                ...dataSourceOptions,
-                name: this.getDataSourceUniqueName(),
-            }, this, 'dataSources');
-        } else if (typeof options === 'string') {
-            dataSource = DataSource.from({
-                ...dataSourceOptions,
-                name: options,
-            }, this, 'dataSources');
-        } else if (options instanceof DataSource) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            dataSource = options;
-            Object.assign(dataSource, relationOptions);
-        } else {
-            dataSource = DataSource.from({
-                ...dataSourceOptions,
-                ...options,
-            }, this, 'dataSources');
-        }
-        this.dataSources.splice(index, 0, dataSource);
-        return dataSource;
-    }
-
-    /**
-     * 插入数据源
-     * @param name 数据源名称，如果不填会自动生成一个唯一名称
-     */
-    insertDataSourceAt(name: string, index: number): DataSource;
-
-    /**
-     * 插入数据源
-     * @param dataSourceOptions 数据源参数
-     */
-    insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
-
-    /**
-     * 插入数据源
-     * @param dataSource 已有的数据源实例
-     */
-    insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
-
-    insertDataSourceAt(options: string | Partial<DataSource> | DataSource, index: number) {
-        const node = this._insertDataSourceAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'dataSources',
-        });
-        return node;
-    }
-
-    /**
-     * 添加数据源
-     * @internal
-     * @param name 数据源名称，如果不填会自动生成一个唯一名称
-     */
-    _addDataSource(name?: string): DataSource;
-
-    /**
-     * 添加数据源
-     * @internal
-     * @param dataSourceOptions 数据源参数
-     */
-    _addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
-
-    /**
-     * 添加数据源
-     * @internal
-     * @param dataSource 已有的数据源实例
-     */
-    _addDataSource(dataSource: DataSource): DataSource;
-
-    _addDataSource(options?: string | Partial<DataSource> | DataSource) {
-        const index = 0;
-        return this._insertDataSourceAt(options as any, index);
-    }
-
-    /**
-     * 添加数据源
-     * @internal
-     * @param name 数据源名称，如果不填会自动生成一个唯一名称
-     */
-    addDataSource(name?: string): DataSource;
-
-    /**
-     * 添加数据源
-     * @param dataSourceOptions 数据源参数
-     */
-    addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
-
-    /**
-     * 添加数据源
-     * @param dataSource 已有的数据源实例
-     */
-    addDataSource(dataSource: DataSource): DataSource;
-
-    addDataSource(options?: string | Partial<DataSource> | DataSource) {
-        const node = this._addDataSource(options as any);
-        const index = this.dataSources.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'dataSources',
-        });
-        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;
-    }
-
-
-    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 变量名称，如果不填会自动生成一个唯一名称
-    */
-    _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: '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 变量名称，如果不填会自动生成一个唯一名称
-     */
-    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: 'frontendVariables',
-        });
-        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.frontendVariables.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.frontendVariables.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'frontendVariables',
-        });
-        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;
-    }
-
-
-    getFrontendLibraryExistingNames(excludedList: Array<FrontendLibrary> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.frontends as FrontendLibrary[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getFrontendLibraryUniqueName(name = 'frontendLibrary1') {
-        return utils.unique(name, this.getFrontendLibraryExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入端包
-    * @internal
-    * @param name 端包名称，如果不填会自动生成一个唯一名称
-    */
-    _insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
-
-    /**
-    * 插入端包
-    * @internal
-    * @param frontendLibraryOptions 端包参数
-    */
-    _insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
-
-    /**
-    * 插入端包
-    * @internal
-    * @param frontendLibrary 已有的端包实例
-    */
-    _insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
-
-    _insertFrontendLibraryAt(options: string | Partial<FrontendLibrary> | FrontendLibrary, index: number) {
-        const frontendLibraryOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'frontends' };
-        let frontendLibrary: FrontendLibrary;
-        if (!options) {
-            frontendLibrary = FrontendLibrary.from({
-                ...frontendLibraryOptions,
-                name: this.getFrontendLibraryUniqueName(),
-            }, this, 'frontends');
-        } else if (typeof options === 'string') {
-            frontendLibrary = FrontendLibrary.from({
-                ...frontendLibraryOptions,
-                name: options,
-            }, this, 'frontends');
-        } else if (options instanceof FrontendLibrary) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            frontendLibrary = options;
-            Object.assign(frontendLibrary, relationOptions);
-        } else {
-            frontendLibrary = FrontendLibrary.from({
-                ...frontendLibraryOptions,
-                ...options,
-            }, this, 'frontends');
-        }
-        this.frontends.splice(index, 0, frontendLibrary);
-        return frontendLibrary;
-    }
-
-    /**
-     * 插入端包
-     * @param name 端包名称，如果不填会自动生成一个唯一名称
-     */
-    insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
-
-    /**
-     * 插入端包
-     * @param frontendLibraryOptions 端包参数
-     */
-    insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
-
-    /**
-     * 插入端包
-     * @param frontendLibrary 已有的端包实例
-     */
-    insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
-
-    insertFrontendLibraryAt(options: string | Partial<FrontendLibrary> | FrontendLibrary, index: number) {
-        const node = this._insertFrontendLibraryAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'frontends',
-        });
-        return node;
-    }
-
-    /**
-     * 添加端包
-     * @internal
-     * @param name 端包名称，如果不填会自动生成一个唯一名称
-     */
-    _addFrontendLibrary(name?: string): FrontendLibrary;
-
-    /**
-     * 添加端包
-     * @internal
-     * @param frontendLibraryOptions 端包参数
-     */
-    _addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
-
-    /**
-     * 添加端包
-     * @internal
-     * @param frontendLibrary 已有的端包实例
-     */
-    _addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
-
-    _addFrontendLibrary(options?: string | Partial<FrontendLibrary> | FrontendLibrary) {
-        const index = this.frontends.length;
-        return this._insertFrontendLibraryAt(options as any, index);
-    }
-
-    /**
-     * 添加端包
-     * @internal
-     * @param name 端包名称，如果不填会自动生成一个唯一名称
-     */
-    addFrontendLibrary(name?: string): FrontendLibrary;
-
-    /**
-     * 添加端包
-     * @param frontendLibraryOptions 端包参数
-     */
-    addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
-
-    /**
-     * 添加端包
-     * @param frontendLibrary 已有的端包实例
-     */
-    addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
-
-    addFrontendLibrary(options?: string | Partial<FrontendLibrary> | FrontendLibrary) {
-        const node = this._addFrontendLibrary(options as any);
-        const index = this.frontends.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'frontends',
-        });
-        return node;
-    }
-
-
-
-    getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
-        const excludedSet = new Set(excludedList);
-        return ((this.triggerLaunchers as TriggerLauncher[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-    }
-    getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
-        return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
-    }
-
-    /**
-    * 插入触发器启动器
-    * @internal
-    * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-    */
-    _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
-
-    /**
-    * 插入触发器启动器
-    * @internal
-    * @param triggerLauncherOptions 触发器启动器参数
-    */
-    _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
-
-    /**
-    * 插入触发器启动器
-    * @internal
-    * @param triggerLauncher 已有的触发器启动器实例
-    */
-    _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
-
-    _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-        const triggerLauncherOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
-        let triggerLauncher: TriggerLauncher;
-        if (!options) {
-            triggerLauncher = TriggerLauncher.from({
-                ...triggerLauncherOptions,
-                name: this.getTriggerLauncherUniqueName(),
-            }, this, 'triggerLaunchers');
-        } else if (typeof options === 'string') {
-            triggerLauncher = TriggerLauncher.from({
-                ...triggerLauncherOptions,
-                name: options,
-            }, this, 'triggerLaunchers');
-        } else if (options instanceof TriggerLauncher) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            triggerLauncher = options;
-            Object.assign(triggerLauncher, relationOptions);
-        } else {
-            triggerLauncher = TriggerLauncher.from({
-                ...triggerLauncherOptions,
-                ...options,
-            }, this, 'triggerLaunchers');
-        }
-        this.triggerLaunchers.splice(index, 0, triggerLauncher);
-        return triggerLauncher;
-    }
-
-    /**
-     * 插入触发器启动器
-     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-     */
-    insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
-
-    /**
-     * 插入触发器启动器
-     * @param triggerLauncherOptions 触发器启动器参数
-     */
-    insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
-
-    /**
-     * 插入触发器启动器
-     * @param triggerLauncher 已有的触发器启动器实例
-     */
-    insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
-
-    insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-        const node = this._insertTriggerLauncherAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'triggerLaunchers',
-        });
-        return node;
-    }
-
-    /**
-     * 添加触发器启动器
-     * @internal
-     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-     */
-    _addTriggerLauncher(name?: string): TriggerLauncher;
-
-    /**
-     * 添加触发器启动器
-     * @internal
-     * @param triggerLauncherOptions 触发器启动器参数
-     */
-    _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
-
-    /**
-     * 添加触发器启动器
-     * @internal
-     * @param triggerLauncher 已有的触发器启动器实例
-     */
-    _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
-
-    _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-        const index = 0;
-        return this._insertTriggerLauncherAt(options as any, index);
-    }
-
-    /**
-     * 添加触发器启动器
-     * @internal
-     * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-     */
-    addTriggerLauncher(name?: string): TriggerLauncher;
-
-    /**
-     * 添加触发器启动器
-     * @param triggerLauncherOptions 触发器启动器参数
-     */
-    addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
-
-    /**
-     * 添加触发器启动器
-     * @param triggerLauncher 已有的触发器启动器实例
-     */
-    addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
-
-    addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-        const node = this._addTriggerLauncher(options as any);
-        const index = this.triggerLaunchers.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'triggerLaunchers',
-        });
-        return node;
-    }
-
-
-    
-
-    /**
-    * 删除数据源
-    * @param name 数据源名称
-    */
-    removeDataSource(name: string): void;
-
-    /**
-     * 删除数据源
-     * @param dataSource 已有的数据源实例
-     */
-    removeDataSource(dataSource: DataSource): void;
-
-    removeDataSource(options: string | DataSource) {
-        let dataSource: DataSource;
-        if (typeof options === 'string') {
-            dataSource = (this.dataSources as DataSource[]).find((item) => item.name === options);
-            if (!dataSource) {
-                throw new Error('找不到数据源 ' + options);
-            }
-        } else {
-            dataSource = options;
-        }
-        return dataSource.delete();
-    }
-
-    __removeDataSource(dataSource: DataSource) {
-        const parentKey = dataSource.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: dataSource,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(dataSource);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === dataSource) {
-                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 接口名称
-    */
-    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 变量名称
-    */
-    removeVariable(name: string): void;
-
-    /**
-     * 删除变量
-     * @param variable 已有的变量实例
-     */
-    removeVariable(variable: Variable): void;
-
-    removeVariable(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();
-    }
-
-    __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 流程名称
-    */
-    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 端包名称
-    */
-    removeFrontendLibrary(name: string): void;
-
-    /**
-     * 删除端包
-     * @param frontendLibrary 已有的端包实例
-     */
-    removeFrontendLibrary(frontendLibrary: FrontendLibrary): void;
-
-    removeFrontendLibrary(options: string | FrontendLibrary) {
-        let frontendLibrary: FrontendLibrary;
-        if (typeof options === 'string') {
-            frontendLibrary = (this.frontends as FrontendLibrary[]).find((item) => item.name === options);
-            if (!frontendLibrary) {
-                throw new Error('找不到端包 ' + options);
-            }
-        } else {
-            frontendLibrary = options;
-        }
-        return frontendLibrary.delete();
-    }
-
-    __removeFrontendLibrary(frontendLibrary: FrontendLibrary) {
-        const parentKey = frontendLibrary.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: frontendLibrary,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(frontendLibrary);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === frontendLibrary) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除配置管理
-    * @param name 配置管理名称
-    */
-    removeConfiguration(name: string): void;
-
-    /**
-     * 删除配置管理
-     * @param configuration 已有的配置管理实例
-     */
-    removeConfiguration(configuration: Configuration): void;
-
-    removeConfiguration(options: string | Configuration) {
-        let configuration: Configuration;
-        if (typeof options === 'string') {
-            configuration = this.configuration;
-            if (!configuration) {
-                throw new Error('找不到配置管理 ' + options);
-            }
-        } else {
-            configuration = options;
-        }
-        return configuration.delete();
-    }
-
-    __removeConfiguration(configuration: Configuration) {
-        const parentKey = configuration.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: configuration,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(configuration);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === configuration) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-
-
-    /**
-    * 删除触发器启动器
-    * @param name 触发器启动器名称
-    */
-    removeTriggerLauncher(name: string): void;
-
-    /**
-     * 删除触发器启动器
-     * @param triggerLauncher 已有的触发器启动器实例
-     */
-    removeTriggerLauncher(triggerLauncher: TriggerLauncher): void;
-
-    removeTriggerLauncher(options: string | TriggerLauncher) {
-        let triggerLauncher: TriggerLauncher;
-        if (typeof options === 'string') {
-            triggerLauncher = (this.triggerLaunchers as TriggerLauncher[]).find((item) => item.name === options);
-            if (!triggerLauncher) {
-                throw new Error('找不到触发器启动器 ' + options);
-            }
-        } else {
-            triggerLauncher = options;
-        }
-        return triggerLauncher.delete();
-    }
-
-    __removeTriggerLauncher(triggerLauncher: TriggerLauncher) {
-        const parentKey = triggerLauncher.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: triggerLauncher,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(triggerLauncher);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === triggerLauncher) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
-    }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-    /**
-     * 用于区分存量应用新导入模块,存量应用替换数据结构使用
-     */
-     @property()
-     isAdd: boolean;
-
-    /**
-     * 是否启动
-     */
-    @property()
-    enable: boolean;
-
-    /**
-     * 依赖列表
-     */
-    @property()
-    dependencies: Array<string> = [];
-
-    setIsAdd(isAdd: boolean) {
-        const object = {
-            isAdd,
-        };
-        this.update({
-            ...object,
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'Module' | 'Connector' = 'Module';
+
+  /**
+   * type
+   */
+  @property()
+  type: 'extension' | 'interface' | 'component' | 'connector' = undefined;
+
+  /**
+   * version
+   */
+  @property()
+  version: string = undefined;
+
+  /**
+   * 模块名称
+   */
+  @property()
+  name: string = undefined;
+
+  /**
+   * 模块标题
+   */
+  @property()
+  title: string = undefined;
+
+  /**
+   * 模块描述
+   */
+  @property()
+  description: string = undefined;
+
+  /**
+   * provider
+   */
+  @property()
+  provider: string = undefined;
+
+  /**
+   * 外部语言依赖
+   */
+  @property()
+  externalDependencyMap: { maven?: Array<{ groupId: string; artifactId: string; version: string }> } = undefined;
+
+  /**
+   * 外部语言依赖
+   */
+  @property()
+  compilerInfoMap: {
+    java?: Array<{ packageName: string; className: string; naslName: string; type: string; javaTypes: any }>;
+    js?: { prefix: string };
+  } = undefined;
+
+  /**
+   * 数据源列表
+   */
+  @property('DataSource')
+  dataSources: Array<DataSource> = [];
+
+  /**
+   * 数据结构列表
+   */
+  @property('Structure')
+  structures: Array<Structure> = [];
+
+  /**
+   * 枚举列表
+   */
+  @property('Enum')
+  enums: Array<Enum> = [];
+
+  /**
+   * 逻辑列表
+   */
+  @property('Logic')
+  logics: Array<Logic> = [];
+
+  /**
+   * 接口列表
+   */
+  @property('Interface')
+  interfaces: Array<Interface> = [];
+
+  /**
+   * 页面列表
+   */
+  @property('View')
+  views: Array<View> = [];
+
+  /**
+   * 变量列表
+   */
+  @property('Variable')
+  frontendVariables: Array<Variable> = [];
+
+  /**
+   * 流程列表
+   */
+  @property('Process')
+  processes: Array<Process> = [];
+
+  /**
+   * 端包列表
+   */
+  @property('FrontendLibrary')
+  frontends: Array<FrontendLibrary> = [];
+
+  /**
+   * 配置管理
+   */
+  @property('Configuration')
+  configuration: Configuration = undefined;
+
+  /**
+   * 触发器启动器列表
+   */
+  @property('TriggerLauncher')
+  triggerLaunchers: Array<TriggerLauncher> = [];
+
+  /**
+   * 连接列表
+   */
+  @property('Connection')
+  connections: Array<Connection> = [];
+
+  /**
+   * 祖先 App
+   */
+  get app() {
+    return this.getAncestor('App') as App;
+  }
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<Module>) {
+    // @ts-ignore
+    source = { ...Module.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'Module';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): Module {
+    return super.from(source, parentNode, parentKey) as Module;
+  }
+
+  /**
+   * 从父级删除该节点
+   * @internal
+   */
+  _delete() {
+    let params: Params = null;
+    if (this.parentNode) {
+      params = (this.parentNode as any)?.__removeModule?.(this);
+    }
+    return params;
+  }
+
+  getDataSourceExistingNames(excludedList: Array<DataSource> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.dataSources as DataSource[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getDataSourceUniqueName(name = 'dataSource1') {
+    return utils.unique(name, this.getDataSourceExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入数据源
+   * @internal
+   * @param name 数据源名称，如果不填会自动生成一个唯一名称
+   */
+  _insertDataSourceAt(name: string, index: number): DataSource;
+
+  /**
+   * 插入数据源
+   * @internal
+   * @param dataSourceOptions 数据源参数
+   */
+  _insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
+
+  /**
+   * 插入数据源
+   * @internal
+   * @param dataSource 已有的数据源实例
+   */
+  _insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
+
+  _insertDataSourceAt(options: string | Partial<DataSource> | DataSource, index: number) {
+    const dataSourceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'dataSources' };
+    let dataSource: DataSource;
+    if (!options) {
+      dataSource = DataSource.from(
+        {
+          ...dataSourceOptions,
+          name: this.getDataSourceUniqueName(),
+        },
+        this,
+        'dataSources'
+      );
+    } else if (typeof options === 'string') {
+      dataSource = DataSource.from(
+        {
+          ...dataSourceOptions,
+          name: options,
+        },
+        this,
+        'dataSources'
+      );
+    } else if (options instanceof DataSource) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      dataSource = options;
+      Object.assign(dataSource, relationOptions);
+    } else {
+      dataSource = DataSource.from(
+        {
+          ...dataSourceOptions,
+          ...options,
+        },
+        this,
+        'dataSources'
+      );
+    }
+    this.dataSources.splice(index, 0, dataSource);
+    return dataSource;
+  }
+
+  /**
+   * 插入数据源
+   * @param name 数据源名称，如果不填会自动生成一个唯一名称
+   */
+  insertDataSourceAt(name: string, index: number): DataSource;
+
+  /**
+   * 插入数据源
+   * @param dataSourceOptions 数据源参数
+   */
+  insertDataSourceAt(dataSourceOptions: Partial<DataSource>, index: number): DataSource;
+
+  /**
+   * 插入数据源
+   * @param dataSource 已有的数据源实例
+   */
+  insertDataSourceAt(dataSource: DataSource, index: number): DataSource;
+
+  insertDataSourceAt(options: string | Partial<DataSource> | DataSource, index: number) {
+    const node = this._insertDataSourceAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'dataSources',
+    });
+    return node;
+  }
+
+  /**
+   * 添加数据源
+   * @internal
+   * @param name 数据源名称，如果不填会自动生成一个唯一名称
+   */
+  _addDataSource(name?: string): DataSource;
+
+  /**
+   * 添加数据源
+   * @internal
+   * @param dataSourceOptions 数据源参数
+   */
+  _addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
+
+  /**
+   * 添加数据源
+   * @internal
+   * @param dataSource 已有的数据源实例
+   */
+  _addDataSource(dataSource: DataSource): DataSource;
+
+  _addDataSource(options?: string | Partial<DataSource> | DataSource) {
+    const index = 0;
+    return this._insertDataSourceAt(options as any, index);
+  }
+
+  /**
+   * 添加数据源
+   * @internal
+   * @param name 数据源名称，如果不填会自动生成一个唯一名称
+   */
+  addDataSource(name?: string): DataSource;
+
+  /**
+   * 添加数据源
+   * @param dataSourceOptions 数据源参数
+   */
+  addDataSource(dataSourceOptions: Partial<DataSource>): DataSource;
+
+  /**
+   * 添加数据源
+   * @param dataSource 已有的数据源实例
+   */
+  addDataSource(dataSource: DataSource): DataSource;
+
+  addDataSource(options?: string | Partial<DataSource> | DataSource) {
+    const node = this._addDataSource(options as any);
+    const index = this.dataSources.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'dataSources',
+    });
+    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;
+  }
+
+  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 变量名称，如果不填会自动生成一个唯一名称
+   */
+  _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: '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 变量名称，如果不填会自动生成一个唯一名称
+   */
+  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: 'frontendVariables',
+    });
+    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.frontendVariables.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.frontendVariables.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'frontendVariables',
+    });
+    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;
+  }
+
+  getFrontendLibraryExistingNames(excludedList: Array<FrontendLibrary> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.frontends as FrontendLibrary[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getFrontendLibraryUniqueName(name = 'frontendLibrary1') {
+    return utils.unique(name, this.getFrontendLibraryExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入端包
+   * @internal
+   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   */
+  _insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
+
+  /**
+   * 插入端包
+   * @internal
+   * @param frontendLibraryOptions 端包参数
+   */
+  _insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
+
+  /**
+   * 插入端包
+   * @internal
+   * @param frontendLibrary 已有的端包实例
+   */
+  _insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
+
+  _insertFrontendLibraryAt(options: string | Partial<FrontendLibrary> | FrontendLibrary, index: number) {
+    const frontendLibraryOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'frontends' };
+    let frontendLibrary: FrontendLibrary;
+    if (!options) {
+      frontendLibrary = FrontendLibrary.from(
+        {
+          ...frontendLibraryOptions,
+          name: this.getFrontendLibraryUniqueName(),
+        },
+        this,
+        'frontends'
+      );
+    } else if (typeof options === 'string') {
+      frontendLibrary = FrontendLibrary.from(
+        {
+          ...frontendLibraryOptions,
+          name: options,
+        },
+        this,
+        'frontends'
+      );
+    } else if (options instanceof FrontendLibrary) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      frontendLibrary = options;
+      Object.assign(frontendLibrary, relationOptions);
+    } else {
+      frontendLibrary = FrontendLibrary.from(
+        {
+          ...frontendLibraryOptions,
+          ...options,
+        },
+        this,
+        'frontends'
+      );
+    }
+    this.frontends.splice(index, 0, frontendLibrary);
+    return frontendLibrary;
+  }
+
+  /**
+   * 插入端包
+   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   */
+  insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
+
+  /**
+   * 插入端包
+   * @param frontendLibraryOptions 端包参数
+   */
+  insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
+
+  /**
+   * 插入端包
+   * @param frontendLibrary 已有的端包实例
+   */
+  insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
+
+  insertFrontendLibraryAt(options: string | Partial<FrontendLibrary> | FrontendLibrary, index: number) {
+    const node = this._insertFrontendLibraryAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'frontends',
+    });
+    return node;
+  }
+
+  /**
+   * 添加端包
+   * @internal
+   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   */
+  _addFrontendLibrary(name?: string): FrontendLibrary;
+
+  /**
+   * 添加端包
+   * @internal
+   * @param frontendLibraryOptions 端包参数
+   */
+  _addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
+
+  /**
+   * 添加端包
+   * @internal
+   * @param frontendLibrary 已有的端包实例
+   */
+  _addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
+
+  _addFrontendLibrary(options?: string | Partial<FrontendLibrary> | FrontendLibrary) {
+    const index = this.frontends.length;
+    return this._insertFrontendLibraryAt(options as any, index);
+  }
+
+  /**
+   * 添加端包
+   * @internal
+   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   */
+  addFrontendLibrary(name?: string): FrontendLibrary;
+
+  /**
+   * 添加端包
+   * @param frontendLibraryOptions 端包参数
+   */
+  addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
+
+  /**
+   * 添加端包
+   * @param frontendLibrary 已有的端包实例
+   */
+  addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
+
+  addFrontendLibrary(options?: string | Partial<FrontendLibrary> | FrontendLibrary) {
+    const node = this._addFrontendLibrary(options as any);
+    const index = this.frontends.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'frontends',
+    });
+    return node;
+  }
+
+  getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.triggerLaunchers as TriggerLauncher[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+    return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @internal
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+
+  _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const triggerLauncherOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+    let triggerLauncher: TriggerLauncher;
+    if (!options) {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          name: this.getTriggerLauncherUniqueName(),
+        },
+        this,
+        'triggerLaunchers'
+      );
+    } else if (typeof options === 'string') {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          name: options,
+        },
+        this,
+        'triggerLaunchers'
+      );
+    } else if (options instanceof TriggerLauncher) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      triggerLauncher = options;
+      Object.assign(triggerLauncher, relationOptions);
+    } else {
+      triggerLauncher = TriggerLauncher.from(
+        {
+          ...triggerLauncherOptions,
+          ...options,
+        },
+        this,
+        'triggerLaunchers'
+      );
+    }
+    this.triggerLaunchers.splice(index, 0, triggerLauncher);
+    return triggerLauncher;
+  }
+
+  /**
+   * 插入触发器启动器
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+
+  /**
+   * 插入触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+
+  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const node = this._insertTriggerLauncherAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'triggerLaunchers',
+    });
+    return node;
+  }
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  _addTriggerLauncher(name?: string): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+
+  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const index = 0;
+    return this._insertTriggerLauncherAt(options as any, index);
+  }
+
+  /**
+   * 添加触发器启动器
+   * @internal
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   */
+  addTriggerLauncher(name?: string): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
+   */
+  addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+
+  /**
+   * 添加触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
+
+  addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const node = this._addTriggerLauncher(options as any);
+    const index = this.triggerLaunchers.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'triggerLaunchers',
+    });
+    return node;
+  }
+
+  getConnectionExistingNames(excludedList: Array<Connection> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.connections as Connection[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getConnectionUniqueName(name = 'connection1') {
+    return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入连接
+   * @internal
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  _insertConnectionAt(name: string, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @internal
+   * @param connectionOptions 连接参数
+   */
+  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @internal
+   * @param connection 已有的连接实例
+   */
+  _insertConnectionAt(connection: Connection, index: number): Connection;
+
+  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const connectionOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'connections' };
+    let connection: Connection;
+    if (!options) {
+      connection = Connection.from(
+        {
+          ...connectionOptions,
+          name: this.getConnectionUniqueName(),
+        },
+        this,
+        'connections'
+      );
+    } else if (typeof options === 'string') {
+      connection = Connection.from(
+        {
+          ...connectionOptions,
+          name: options,
+        },
+        this,
+        'connections'
+      );
+    } else if (options instanceof Connection) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      connection = options;
+      Object.assign(connection, relationOptions);
+    } else {
+      connection = Connection.from(
+        {
+          ...connectionOptions,
+          ...options,
+        },
+        this,
+        'connections'
+      );
+    }
+    this.connections.splice(index, 0, connection);
+    return connection;
+  }
+
+  /**
+   * 插入连接
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  insertConnectionAt(name: string, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @param connectionOptions 连接参数
+   */
+  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+
+  /**
+   * 插入连接
+   * @param connection 已有的连接实例
+   */
+  insertConnectionAt(connection: Connection, index: number): Connection;
+
+  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const node = this._insertConnectionAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'connections',
+    });
+    return node;
+  }
+
+  /**
+   * 添加连接
+   * @internal
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  _addConnection(name?: string): Connection;
+
+  /**
+   * 添加连接
+   * @internal
+   * @param connectionOptions 连接参数
+   */
+  _addConnection(connectionOptions: Partial<Connection>): Connection;
+
+  /**
+   * 添加连接
+   * @internal
+   * @param connection 已有的连接实例
+   */
+  _addConnection(connection: Connection): Connection;
+
+  _addConnection(options?: string | Partial<Connection> | Connection) {
+    const index = 0;
+    return this._insertConnectionAt(options as any, index);
+  }
+
+  /**
+   * 添加连接
+   * @internal
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   */
+  addConnection(name?: string): Connection;
+
+  /**
+   * 添加连接
+   * @param connectionOptions 连接参数
+   */
+  addConnection(connectionOptions: Partial<Connection>): Connection;
+
+  /**
+   * 添加连接
+   * @param connection 已有的连接实例
+   */
+  addConnection(connection: Connection): Connection;
+
+  addConnection(options?: string | Partial<Connection> | Connection) {
+    const node = this._addConnection(options as any);
+    const index = this.connections.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'connections',
+    });
+    return node;
+  }
+
+  /**
+   * 删除数据源
+   * @param name 数据源名称
+   */
+  removeDataSource(name: string): void;
+
+  /**
+   * 删除数据源
+   * @param dataSource 已有的数据源实例
+   */
+  removeDataSource(dataSource: DataSource): void;
+
+  removeDataSource(options: string | DataSource) {
+    let dataSource: DataSource;
+    if (typeof options === 'string') {
+      dataSource = (this.dataSources as DataSource[]).find((item) => item.name === options);
+      if (!dataSource) {
+        throw new Error(`找不到数据源 ${options}`);
+      }
+    } else {
+      dataSource = options;
+    }
+    return dataSource.delete();
+  }
+
+  __removeDataSource(dataSource: DataSource) {
+    const { parentKey } = dataSource;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: dataSource,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(dataSource);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === dataSource) {
+        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 接口名称
+   */
+  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 变量名称
+   */
+  removeVariable(name: string): void;
+
+  /**
+   * 删除变量
+   * @param variable 已有的变量实例
+   */
+  removeVariable(variable: Variable): void;
+
+  removeVariable(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();
+  }
+
+  __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 流程名称
+   */
+  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 端包名称
+   */
+  removeFrontendLibrary(name: string): void;
+
+  /**
+   * 删除端包
+   * @param frontendLibrary 已有的端包实例
+   */
+  removeFrontendLibrary(frontendLibrary: FrontendLibrary): void;
+
+  removeFrontendLibrary(options: string | FrontendLibrary) {
+    let frontendLibrary: FrontendLibrary;
+    if (typeof options === 'string') {
+      frontendLibrary = (this.frontends as FrontendLibrary[]).find((item) => item.name === options);
+      if (!frontendLibrary) {
+        throw new Error(`找不到端包 ${options}`);
+      }
+    } else {
+      frontendLibrary = options;
+    }
+    return frontendLibrary.delete();
+  }
+
+  __removeFrontendLibrary(frontendLibrary: FrontendLibrary) {
+    const { parentKey } = frontendLibrary;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: frontendLibrary,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(frontendLibrary);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === frontendLibrary) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除配置管理
+   * @param name 配置管理名称
+   */
+  removeConfiguration(name: string): void;
+
+  /**
+   * 删除配置管理
+   * @param configuration 已有的配置管理实例
+   */
+  removeConfiguration(configuration: Configuration): void;
+
+  removeConfiguration(options: string | Configuration) {
+    let configuration: Configuration;
+    if (typeof options === 'string') {
+      configuration = this.configuration;
+      if (!configuration) {
+        throw new Error(`找不到配置管理 ${options}`);
+      }
+    } else {
+      configuration = options;
+    }
+    return configuration.delete();
+  }
+
+  __removeConfiguration(configuration: Configuration) {
+    const { parentKey } = configuration;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: configuration,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(configuration);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === configuration) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除触发器启动器
+   * @param name 触发器启动器名称
+   */
+  removeTriggerLauncher(name: string): void;
+
+  /**
+   * 删除触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
+   */
+  removeTriggerLauncher(triggerLauncher: TriggerLauncher): void;
+
+  removeTriggerLauncher(options: string | TriggerLauncher) {
+    let triggerLauncher: TriggerLauncher;
+    if (typeof options === 'string') {
+      triggerLauncher = (this.triggerLaunchers as TriggerLauncher[]).find((item) => item.name === options);
+      if (!triggerLauncher) {
+        throw new Error(`找不到触发器启动器 ${options}`);
+      }
+    } else {
+      triggerLauncher = options;
+    }
+    return triggerLauncher.delete();
+  }
+
+  __removeTriggerLauncher(triggerLauncher: TriggerLauncher) {
+    const { parentKey } = triggerLauncher;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: triggerLauncher,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(triggerLauncher);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === triggerLauncher) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  /**
+   * 删除连接
+   * @param name 连接名称
+   */
+  removeConnection(name: string): void;
+
+  /**
+   * 删除连接
+   * @param connection 已有的连接实例
+   */
+  removeConnection(connection: Connection): void;
+
+  removeConnection(options: string | Connection) {
+    let connection: Connection;
+    if (typeof options === 'string') {
+      connection = (this.connections as Connection[]).find((item) => item.name === options);
+      if (!connection) {
+        throw new Error(`找不到连接 ${options}`);
+      }
+    } else {
+      connection = options;
+    }
+    return connection.delete();
+  }
+
+  __removeConnection(connection: Connection) {
+    const { parentKey } = connection;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: connection,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(connection);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === connection) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+  /**
+   * 用于区分存量应用新导入模块,存量应用替换数据结构使用
+   */
+  @property()
+  isAdd: boolean;
+
+  /**
+   * 是否启动
+   */
+  @property()
+  enable: boolean;
+
+  /**
+   * 依赖列表
+   */
+  @property()
+  dependencies: Array<string> = [];
+
+  setIsAdd(isAdd: boolean) {
+    const object = {
+      isAdd,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 生成宿主语言的文件路径
+   * @param name 一般不用传，用于 rename
+   */
+  getEmbeddedFilePath(name = this.name) {
+    return `/embedded/${this.app.name}/${this.parentKey}/${this.name}`;
+  }
+
+  /**
+   * 获取命名空间和
+   * 暂时不考虑 Module 嵌套的情况
+   */
+  getNamespace() {
+    // connector namespace 为 connector + connectorName
+    if (this.type === 'connector') {
+      return `connector.${this.name}`;
+    }
+    return `${moduleNameSpace[this.parentKey as ModuleKeyType]}`;
+  }
+
+  getTsNamespace() {
+    if (this.type === 'connector') {
+      return 'connector';
+    }
+    return `${moduleNameSpace[this.parentKey as ModuleKeyType]}`;
+  }
+
+  getTsNamespaceAndName() {
+    if (this.type === 'connector') {
+      return 'connector';
+    }
+    return `${moduleNameSpace[this.parentKey as ModuleKeyType]}.${this.name}`;
+  }
+
+  findEnumByName(name: string) {
+    return this.enums.find((enumItem) => enumItem.name === name);
+  }
+
+  /**
+   *  获取属性节点是否存在
+   */
+
+  findProperty(name: string, propertyType: PropertyType): any {
+    return ((this as any)[propertyType] as Array<any>).find((item) => item.name === name);
+  }
+
+  delete() {
+    this.parentNode?.emit('collect:start', {
+      actionMsg: '移除依赖库',
+    });
+    super.delete();
+    this._delete();
+    // if (this.dependencies) {
+    //     // 删除依赖链中的依赖
+    //     this.dependencies.forEach((tag) => {
+    //         const [name, version] = tag.split('-');
+    //         const existNode = this.app.dependencies.find((m) => m.name === name && m.version === version);
+    //         existNode?.delete();
+    //     });
+    // }
+    // 处理同名依赖 重新生成文件
+    // if (this.enable) {
+    // 删[数据源]
+    const dataSourceGroup = (this.parentNode as any)?.configuration?.getGroup('dataSource');
+    if (this.dataSources && dataSourceGroup) {
+      this.dataSources.forEach((datasource) => {
+        this.parentNode?.emit('clear:datasourceError', datasource as any);
+        try {
+          dataSourceGroup.removeConfigProperty(datasource.name);
+        } catch (e) {}
+      });
+    }
+    // // 已启用的依赖库被删除时，将后续被禁用的同名依赖库 切换为启用
+    // const index = this.app.dependencies.findIndex((m) => m.enable === false && m.name === this.name);
+    // if (index >= 0) {
+    //     const nextMainModule = this.app.dependencies[index];
+    //     // 更新[禁用的依赖]enable:true
+    //     nextMainModule.update({ enable: true });
+    //     nextMainModule.softDelete({ index });
+    // }
+    // }
+    this.parentNode?.emit('collect:end');
+  }
+
+  // 删除再添加 触发文件生成
+  softDelete(options: { index: number }) {
+    // 删[禁用的依赖]
+    super.delete();
+    // 创建[禁用的依赖]
+    this.app.insertModuleInDependenciesAt(this, options.index);
+    // 创建[禁用的依赖]的数据源
+    const dataSourceGroup = (this.parentNode as any)?.configuration?.getGroup('dataSource');
+    if (this.dataSources && dataSourceGroup) {
+      this.dataSources.forEach((datasource) => {
+        const body: ConfigProperty = ConfigProperty.from({
+          name: datasource.name,
+          description: '',
+          isPrivate: false,
+          values: [
+            { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
+            { env: 'online', value: '', concept: 'ConfigPropertyValue' },
+          ],
         });
+        dataSourceGroup.addConfigProperty(body);
+      });
     }
-    /**
-     * 生成宿主语言的文件路径
-     * @param name 一般不用传，用于 rename
-     */
-    getEmbeddedFilePath(name = this.name) {
-        return `/embedded/${this.app.name}/${this.parentKey}/${this.name}`;
-    }
-    /**
-     * 获取命名空间和
-     * 暂时不考虑 Module 嵌套的情况
-     */
-    getNamespace() {
-        if (this.type === 'connector') {
-            return 'connector';
-        }
-        return `${moduleNameSpace[this.parentKey as ModuleKeyType]}`;
-    }
-
-    getTsNamespace() {
-        if (this.type === 'connector') {
-            return 'connector';
-        }
-        return `${moduleNameSpace[this.parentKey as ModuleKeyType]}`;
-    }
-    getTsNamespaceAndName() {
-        if (this.type === 'connector') {
-            return 'connector';
-        }
-        return `${moduleNameSpace[this.parentKey as ModuleKeyType]}.${this.name}`;
-    }
-
-    findEnumByName(name: string) {
-        return this.enums.find((enumItem) => enumItem.name === name);
-    }
-
-    /**
-     *  获取属性节点是否存在
-     */
-
-    findProperty(name: string, propertyType: PropertyType): any {
-        return ((this as any)[propertyType] as Array<any>).find((item) => item.name === name);
-    }
-
-    delete() {
-        this.parentNode?.emit('collect:start', {
-            actionMsg: '移除依赖库',
-        });
-        super.delete();
-        this._delete();
-        // if (this.dependencies) {
-        //     // 删除依赖链中的依赖
-        //     this.dependencies.forEach((tag) => {
-        //         const [name, version] = tag.split('-');
-        //         const existNode = this.app.dependencies.find((m) => m.name === name && m.version === version);
-        //         existNode?.delete();
-        //     });
-        // }
-        // 处理同名依赖 重新生成文件
-        // if (this.enable) {
-        // 删[数据源]
-        const dataSourceGroup = (this.parentNode as any)?.configuration?.getGroup('dataSource');
-        if (this.dataSources && dataSourceGroup) {
-            this.dataSources.forEach((datasource) => {
-                this.parentNode?.emit('clear:datasourceError', datasource as any);
-                try {
-                    dataSourceGroup.removeConfigProperty(datasource.name);
-                } catch (e) {}
-            });
-        }
-        // // 已启用的依赖库被删除时，将后续被禁用的同名依赖库 切换为启用
-        // const index = this.app.dependencies.findIndex((m) => m.enable === false && m.name === this.name);
-        // if (index >= 0) {
-        //     const nextMainModule = this.app.dependencies[index];
-        //     // 更新[禁用的依赖]enable:true
-        //     nextMainModule.update({ enable: true });
-        //     nextMainModule.softDelete({ index });
-        // }
-        // }
-        this.parentNode?.emit('collect:end');
-    }
-
-    // 删除再添加 触发文件生成
-    softDelete(options: { index: number }) {
-        // 删[禁用的依赖]
-        super.delete();
-        // 创建[禁用的依赖]
-        this.app.insertModuleInDependenciesAt(this, options.index);
-        // 创建[禁用的依赖]的数据源
-        const dataSourceGroup = (this.parentNode as any)?.configuration?.getGroup('dataSource');
-        if (this.dataSources && dataSourceGroup) {
-            this.dataSources.forEach((datasource) => {
-                const body: ConfigProperty = ConfigProperty.from({
-                    name: datasource.name,
-                    description: '',
-                    isPrivate: false,
-                    values: [
-                        { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
-                        { env: 'online', value: '', concept: 'ConfigPropertyValue' },
-                    ],
-                });
-                dataSourceGroup.addConfigProperty(body);
-            });
-        }
-    }
+  }
 
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.Module = Module;
 export default Module;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================