@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/src/concepts/App__.ts

@@ -3,6 +3,8 @@ import { getNaslNodeByNodeCallee, getNodeByNodeCallee } from '../automate/engine
 import ConfigProperty from './ConfigProperty__';
 import TypeAnnotation from './TypeAnnotation__';
 import View from './View__';
+import AuthInterface from './AuthInterface__';
+import Interface from './Interface__';
 // import CallLogic from './CallLogic__';
 
 export interface AssetsInfo {
@@ -19,6 +21,17 @@ interface MessageData {
   resultName?: string;
 }
 
+interface compilerInfoMapProps {
+  java?: Array<{
+    packageName: string;
+    className: string;
+    naslName: string;
+    type: string;
+    javaTypes: Map<string, string>;
+  }>;
+  js?: { prefix: string };
+}
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -34,8 +47,7 @@ import Structure from './Structure__';
 import Enum from './Enum__';
 import Logic from './Logic__';
 import OverriddenLogic from './OverriddenLogic__';
-import Interface from './Interface__';
-import AuthInterface from './AuthInterface__';
+import AbstractInterface from './AbstractInterface__';
 import Frontend from './Frontend__';
 import Backend from './Backend__';
 import Process from './Process__';
@@ -59,6 +71,9 @@ export class App extends BaseNode {
   /** 类名 */
   static readonly ConceptName = 'App';
 
+  /** 继承链 */
+  static readonly inheritanceChain = ['BaseNode'];
+
   /**
    * 应用 Id
    */
@@ -180,14 +195,14 @@ export class App extends BaseNode {
   overriddenLogics: Array<OverriddenLogic> = [];
 
   /**
-   * interfaces
+   * 接口列表
    */
   @property({
-    objectRef: 'Interface | AuthInterface',
+    objectRef: 'AbstractInterface',
     isArray: true,
     defaultValue: [],
   })
-  interfaces: Array<Interface | AuthInterface> = [];
+  interfaces: Array<AbstractInterface> = [];
 
   /**
    * 前端列表
@@ -1096,6 +1111,184 @@ export class App extends BaseNode {
     return node;
   }
 
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    name: string,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  _insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const authLogicForCallInterfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+    let authLogicForCallInterface: AuthLogicForCallInterface;
+    if (!options) {
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
+        {
+          ...authLogicForCallInterfaceOptions,
+          name: this.getAuthLogicForCallInterfaceUniqueName(),
+        },
+        this,
+        'authLogicsForCallInterface',
+      );
+    } else if (typeof options === 'string') {
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
+        {
+          ...authLogicForCallInterfaceOptions,
+          name: options,
+        },
+        this,
+        'authLogicsForCallInterface',
+      );
+    } else if (options instanceof AuthLogicForCallInterface) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      authLogicForCallInterface = options;
+      Object.assign(authLogicForCallInterface, relationOptions);
+    } else {
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
+        {
+          ...authLogicForCallInterfaceOptions,
+          ...options,
+        },
+        this,
+        'authLogicsForCallInterface',
+      );
+    }
+    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+    return authLogicForCallInterface;
+  }
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const node = this._insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogicsForCallInterface',
+    });
+    return node;
+  }
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name?: string): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+  ): AuthLogicForCallInterface;
+
+  _addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+  ) {
+    const index = this.authLogicsForCallInterface.length;
+    return this._insertAuthLogicForCallInterfaceInAuthLogicsForCallInterfaceAt(options as any, index);
+  }
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name?: string): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+  ): AuthLogicForCallInterface;
+
+  addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+  ) {
+    const node = this._addAuthLogicForCallInterfaceInAuthLogicsForCallInterface(options as any);
+    const index = this.authLogicsForCallInterface.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogicsForCallInterface',
+    });
+    return node;
+  }
+
   getOverriddenLogicExistingNames(excludedList: Array<OverriddenLogic> = []) {
     const excludedSet = new Set(excludedList);
     return ((this.overriddenLogics as OverriddenLogic[]) || [])
@@ -1251,795 +1444,797 @@ export class App extends BaseNode {
     return node;
   }
 
-  getInterfaceExistingNames(excludedList: Array<Interface> = []) {
+  getAbstractInterfaceExistingNames(excludedList: Array<AbstractInterface> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.interfaces as AbstractInterface[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
   }
-  getInterfaceUniqueName(name = 'Interface1') {
-    return utils.unique(name, this.getInterfaceExistingNames(), undefined, true);
+  getAbstractInterfaceUniqueName(name = 'Interface1') {
+    return utils.unique(name, this.getAbstractInterfaceExistingNames(), undefined, true);
+  }
+
+  getFrontendExistingNames(excludedList: Array<Frontend> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getFrontendUniqueName(name = 'frontend1') {
+    return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
   }
 
   /**
-   * 插入接口
+   * 插入前端
    * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  _insertInterfaceInInterfacesAt(name: string, index: number): Interface;
+  _insertFrontendAt(name: string, index: number): Frontend;
 
   /**
-   * 插入接口
+   * 插入前端
    * @internal
-   * @param itfaceOptions 接口参数
+   * @param frontendOptions 前端参数
    */
-  _insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+  _insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
 
   /**
-   * 插入接口
+   * 插入前端
    * @internal
-   * @param itface 已有的接口实例
+   * @param frontend 已有的前端实例
    */
-  _insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
+  _insertFrontendAt(frontend: Frontend, index: number): Frontend;
 
-  _insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
-    const itfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
-    let itface: Interface;
+  _insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
+    const frontendOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'frontends' };
+    let frontend: Frontend;
     if (!options) {
-      itface = Interface.from(
+      frontend = Frontend.from(
         {
-          ...itfaceOptions,
-          name: this.getInterfaceUniqueName(),
+          ...frontendOptions,
+          name: this.getFrontendUniqueName(),
         },
         this,
-        'interfaces',
+        'frontends',
       );
     } else if (typeof options === 'string') {
-      itface = Interface.from(
+      frontend = Frontend.from(
         {
-          ...itfaceOptions,
+          ...frontendOptions,
           name: options,
         },
         this,
-        'interfaces',
+        'frontends',
       );
-    } else if (options instanceof Interface) {
+    } else if (options instanceof Frontend) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      itface = options;
-      Object.assign(itface, relationOptions);
+      frontend = options;
+      Object.assign(frontend, relationOptions);
     } else {
-      itface = Interface.from(
+      frontend = Frontend.from(
         {
-          ...itfaceOptions,
+          ...frontendOptions,
           ...options,
         },
         this,
-        'interfaces',
+        'frontends',
       );
     }
-    this.interfaces.splice(index, 0, itface);
-    return itface;
+    this.frontends.splice(index, 0, frontend);
+    return frontend;
   }
 
   /**
-   * 插入接口
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * 插入前端
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  insertInterfaceInInterfacesAt(name: string, index: number): Interface;
+  insertFrontendAt(name: string, index: number): Frontend;
 
   /**
-   * 插入接口
-   * @param itfaceOptions 接口参数
+   * 插入前端
+   * @param frontendOptions 前端参数
    */
-  insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+  insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
 
   /**
-   * 插入接口
-   * @param itface 已有的接口实例
+   * 插入前端
+   * @param frontend 已有的前端实例
    */
-  insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
+  insertFrontendAt(frontend: Frontend, index: number): Frontend;
 
-  insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
-    const node = this._insertInterfaceInInterfacesAt(options as any, index);
+  insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
+    const node = this._insertFrontendAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'interfaces',
+      parentKey: 'frontends',
     });
     return node;
   }
 
   /**
-   * 添加接口
+   * 添加前端
    * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  _addInterfaceInInterfaces(name?: string): Interface;
+  _addFrontend(name?: string): Frontend;
 
   /**
-   * 添加接口
+   * 添加前端
    * @internal
-   * @param itfaceOptions 接口参数
+   * @param frontendOptions 前端参数
    */
-  _addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
+  _addFrontend(frontendOptions: Partial<Frontend>): Frontend;
 
   /**
-   * 添加接口
+   * 添加前端
    * @internal
-   * @param itface 已有的接口实例
+   * @param frontend 已有的前端实例
    */
-  _addInterfaceInInterfaces(itface: Interface): Interface;
+  _addFrontend(frontend: Frontend): Frontend;
 
-  _addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
-    const index = 0;
-    return this._insertInterfaceInInterfacesAt(options as any, index);
+  _addFrontend(options?: string | Partial<Frontend> | Frontend) {
+    const index = this.frontends.length;
+    return this._insertFrontendAt(options as any, index);
   }
 
   /**
-   * 添加接口
+   * 添加前端
    * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * @param name 前端名称，如果不填会自动生成一个唯一名称
    */
-  addInterfaceInInterfaces(name?: string): Interface;
+  addFrontend(name?: string): Frontend;
 
   /**
-   * 添加接口
-   * @param itfaceOptions 接口参数
+   * 添加前端
+   * @param frontendOptions 前端参数
    */
-  addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
+  addFrontend(frontendOptions: Partial<Frontend>): Frontend;
 
   /**
-   * 添加接口
-   * @param itface 已有的接口实例
+   * 添加前端
+   * @param frontend 已有的前端实例
    */
-  addInterfaceInInterfaces(itface: Interface): Interface;
+  addFrontend(frontend: Frontend): Frontend;
 
-  addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
-    const node = this._addInterfaceInInterfaces(options as any);
-    const index = this.interfaces.indexOf(node);
+  addFrontend(options?: string | Partial<Frontend> | Frontend) {
+    const node = this._addFrontend(options as any);
+    const index = this.frontends.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'interfaces',
+      parentKey: 'frontends',
     });
     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, true);
+  }
+
   /**
-   * 插入鉴权接口
+   * 插入流程
    * @internal
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
    */
-  _insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
+  _insertProcessAt(name: string, index: number): Process;
 
   /**
-   * 插入鉴权接口
+   * 插入流程
    * @internal
-   * @param itfaceOptions 鉴权接口参数
+   * @param processOptions 流程参数
    */
-  _insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
+  _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
 
   /**
-   * 插入鉴权接口
+   * 插入流程
    * @internal
-   * @param itface 已有的鉴权接口实例
+   * @param process 已有的流程实例
    */
-  _insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
+  _insertProcessAt(process: Process, index: number): Process;
 
-  _insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
-    const itfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
-    let itface: AuthInterface;
+  _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
+    const processOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'processes' };
+    let process: Process;
     if (!options) {
-      itface = AuthInterface.from(
+      process = Process.from(
         {
-          ...itfaceOptions,
-          name: this.getAuthInterfaceUniqueName(),
+          ...processOptions,
+          name: this.getProcessUniqueName(),
         },
         this,
-        'interfaces',
+        'processes',
       );
     } else if (typeof options === 'string') {
-      itface = AuthInterface.from(
+      process = Process.from(
         {
-          ...itfaceOptions,
+          ...processOptions,
           name: options,
         },
         this,
-        'interfaces',
+        'processes',
       );
-    } else if (options instanceof AuthInterface) {
+    } else if (options instanceof Process) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      itface = options;
-      Object.assign(itface, relationOptions);
+      process = options;
+      Object.assign(process, relationOptions);
     } else {
-      itface = AuthInterface.from(
+      process = Process.from(
         {
-          ...itfaceOptions,
+          ...processOptions,
           ...options,
         },
         this,
-        'interfaces',
+        'processes',
       );
     }
-    this.interfaces.splice(index, 0, itface);
-    return itface;
+    this.processes.splice(index, 0, process);
+    return process;
   }
 
   /**
-   * 插入鉴权接口
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   * 插入流程
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
    */
-  insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
+  insertProcessAt(name: string, index: number): Process;
 
   /**
-   * 插入鉴权接口
-   * @param itfaceOptions 鉴权接口参数
+   * 插入流程
+   * @param processOptions 流程参数
    */
-  insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
+  insertProcessAt(processOptions: Partial<Process>, index: number): Process;
 
   /**
-   * 插入鉴权接口
-   * @param itface 已有的鉴权接口实例
+   * 插入流程
+   * @param process 已有的流程实例
    */
-  insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
+  insertProcessAt(process: Process, index: number): Process;
 
-  insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
-    const node = this._insertAuthInterfaceInInterfacesAt(options as any, index);
+  insertProcessAt(options: string | Partial<Process> | Process, index: number) {
+    const node = this._insertProcessAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'interfaces',
+      parentKey: 'processes',
     });
     return node;
   }
 
   /**
-   * 添加鉴权接口
+   * 添加流程
    * @internal
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
    */
-  _addAuthInterfaceInInterfaces(name?: string): AuthInterface;
+  _addProcess(name?: string): Process;
 
   /**
-   * 添加鉴权接口
+   * 添加流程
    * @internal
-   * @param itfaceOptions 鉴权接口参数
+   * @param processOptions 流程参数
    */
-  _addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
+  _addProcess(processOptions: Partial<Process>): Process;
 
   /**
-   * 添加鉴权接口
+   * 添加流程
    * @internal
-   * @param itface 已有的鉴权接口实例
+   * @param process 已有的流程实例
    */
-  _addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
+  _addProcess(process: Process): Process;
 
-  _addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
+  _addProcess(options?: string | Partial<Process> | Process) {
     const index = 0;
-    return this._insertAuthInterfaceInInterfacesAt(options as any, index);
+    return this._insertProcessAt(options as any, index);
   }
 
   /**
-   * 添加鉴权接口
+   * 添加流程
    * @internal
-   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   * @param name 流程名称，如果不填会自动生成一个唯一名称
    */
-  addAuthInterfaceInInterfaces(name?: string): AuthInterface;
+  addProcess(name?: string): Process;
 
   /**
-   * 添加鉴权接口
-   * @param itfaceOptions 鉴权接口参数
+   * 添加流程
+   * @param processOptions 流程参数
    */
-  addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
+  addProcess(processOptions: Partial<Process>): Process;
 
   /**
-   * 添加鉴权接口
-   * @param itface 已有的鉴权接口实例
+   * 添加流程
+   * @param process 已有的流程实例
    */
-  addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
+  addProcess(process: Process): Process;
 
-  addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
-    const node = this._addAuthInterfaceInInterfaces(options as any);
-    const index = this.interfaces.indexOf(node);
+  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: 'interfaces',
+      parentKey: 'processes',
     });
     return node;
   }
 
-  getFrontendExistingNames(excludedList: Array<Frontend> = []) {
+  getRoleExistingNames(excludedList: Array<Role> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontends as Frontend[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.roles as Role[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getFrontendUniqueName(name = 'frontend1') {
-    return utils.unique(name, this.getFrontendExistingNames(), undefined, true);
+  getRoleUniqueName(name = 'role1') {
+    return utils.unique(name, this.getRoleExistingNames(), undefined, true);
   }
 
   /**
-   * 插入前端
+   * 插入角色
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 角色名称，如果不填会自动生成一个唯一名称
    */
-  _insertFrontendAt(name: string, index: number): Frontend;
+  _insertRoleAt(name: string, index: number): Role;
 
   /**
-   * 插入前端
+   * 插入角色
    * @internal
-   * @param frontendOptions 前端参数
+   * @param roleOptions 角色参数
    */
-  _insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+  _insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
 
   /**
-   * 插入前端
+   * 插入角色
    * @internal
-   * @param frontend 已有的前端实例
+   * @param role 已有的角色实例
    */
-  _insertFrontendAt(frontend: Frontend, index: number): Frontend;
+  _insertRoleAt(role: Role, index: number): Role;
 
-  _insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
-    const frontendOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'frontends' };
-    let frontend: Frontend;
+  _insertRoleAt(options: string | Partial<Role> | Role, index: number) {
+    const roleOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'roles' };
+    let role: Role;
     if (!options) {
-      frontend = Frontend.from(
+      role = Role.from(
         {
-          ...frontendOptions,
-          name: this.getFrontendUniqueName(),
+          ...roleOptions,
+          name: this.getRoleUniqueName(),
         },
         this,
-        'frontends',
+        'roles',
       );
     } else if (typeof options === 'string') {
-      frontend = Frontend.from(
+      role = Role.from(
         {
-          ...frontendOptions,
+          ...roleOptions,
           name: options,
         },
         this,
-        'frontends',
+        'roles',
       );
-    } else if (options instanceof Frontend) {
+    } else if (options instanceof Role) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      frontend = options;
-      Object.assign(frontend, relationOptions);
+      role = options;
+      Object.assign(role, relationOptions);
     } else {
-      frontend = Frontend.from(
+      role = Role.from(
         {
-          ...frontendOptions,
+          ...roleOptions,
           ...options,
         },
         this,
-        'frontends',
+        'roles',
       );
     }
-    this.frontends.splice(index, 0, frontend);
-    return frontend;
+    this.roles.splice(index, 0, role);
+    return role;
   }
 
   /**
-   * 插入前端
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * 插入角色
+   * @param name 角色名称，如果不填会自动生成一个唯一名称
    */
-  insertFrontendAt(name: string, index: number): Frontend;
+  insertRoleAt(name: string, index: number): Role;
 
   /**
-   * 插入前端
-   * @param frontendOptions 前端参数
+   * 插入角色
+   * @param roleOptions 角色参数
    */
-  insertFrontendAt(frontendOptions: Partial<Frontend>, index: number): Frontend;
+  insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
 
   /**
-   * 插入前端
-   * @param frontend 已有的前端实例
+   * 插入角色
+   * @param role 已有的角色实例
    */
-  insertFrontendAt(frontend: Frontend, index: number): Frontend;
+  insertRoleAt(role: Role, index: number): Role;
 
-  insertFrontendAt(options: string | Partial<Frontend> | Frontend, index: number) {
-    const node = this._insertFrontendAt(options as any, index);
+  insertRoleAt(options: string | Partial<Role> | Role, index: number) {
+    const node = this._insertRoleAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontends',
+      parentKey: 'roles',
     });
     return node;
   }
 
   /**
-   * 添加前端
+   * 添加角色
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 角色名称，如果不填会自动生成一个唯一名称
    */
-  _addFrontend(name?: string): Frontend;
+  _addRole(name?: string): Role;
 
   /**
-   * 添加前端
+   * 添加角色
    * @internal
-   * @param frontendOptions 前端参数
+   * @param roleOptions 角色参数
    */
-  _addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+  _addRole(roleOptions: Partial<Role>): Role;
 
   /**
-   * 添加前端
+   * 添加角色
    * @internal
-   * @param frontend 已有的前端实例
+   * @param role 已有的角色实例
    */
-  _addFrontend(frontend: Frontend): Frontend;
+  _addRole(role: Role): Role;
 
-  _addFrontend(options?: string | Partial<Frontend> | Frontend) {
-    const index = this.frontends.length;
-    return this._insertFrontendAt(options as any, index);
+  _addRole(options?: string | Partial<Role> | Role) {
+    const index = this.roles.length;
+    return this._insertRoleAt(options as any, index);
   }
 
   /**
-   * 添加前端
+   * 添加角色
    * @internal
-   * @param name 前端名称，如果不填会自动生成一个唯一名称
+   * @param name 角色名称，如果不填会自动生成一个唯一名称
    */
-  addFrontend(name?: string): Frontend;
+  addRole(name?: string): Role;
 
   /**
-   * 添加前端
-   * @param frontendOptions 前端参数
+   * 添加角色
+   * @param roleOptions 角色参数
    */
-  addFrontend(frontendOptions: Partial<Frontend>): Frontend;
+  addRole(roleOptions: Partial<Role>): Role;
 
   /**
-   * 添加前端
-   * @param frontend 已有的前端实例
+   * 添加角色
+   * @param role 已有的角色实例
    */
-  addFrontend(frontend: Frontend): Frontend;
+  addRole(role: Role): Role;
 
-  addFrontend(options?: string | Partial<Frontend> | Frontend) {
-    const node = this._addFrontend(options as any);
-    const index = this.frontends.indexOf(node);
+  addRole(options?: string | Partial<Role> | Role) {
+    const node = this._addRole(options as any);
+    const index = this.roles.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'frontends',
+      parentKey: 'roles',
     });
     return node;
   }
 
-  getProcessExistingNames(excludedList: Array<Process> = []) {
+  getModuleExistingNames(excludedList: Array<Module> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.processes as Process[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getProcessUniqueName(name = 'Process1') {
-    return utils.unique(name, this.getProcessExistingNames(), undefined, true);
+  getModuleUniqueName(name = 'module1') {
+    return utils.unique(name, this.getModuleExistingNames(), undefined, false);
   }
 
   /**
-   * 插入流程
+   * 插入模块
    * @internal
-   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  _insertProcessAt(name: string, index: number): Process;
+  _insertModuleInDependenciesAt(name: string, index: number): Module;
 
   /**
-   * 插入流程
+   * 插入模块
    * @internal
-   * @param processOptions 流程参数
+   * @param moduleOptions 模块参数
    */
-  _insertProcessAt(processOptions: Partial<Process>, index: number): Process;
+  _insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
 
   /**
-   * 插入流程
+   * 插入模块
    * @internal
-   * @param process 已有的流程实例
+   * @param module 已有的模块实例
    */
-  _insertProcessAt(process: Process, index: number): Process;
+  _insertModuleInDependenciesAt(module: Module, index: number): Module;
 
-  _insertProcessAt(options: string | Partial<Process> | Process, index: number) {
-    const processOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'processes' };
-    let process: Process;
+  _insertModuleInDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+    const moduleOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+    let module: Module;
     if (!options) {
-      process = Process.from(
+      module = Module.from(
         {
-          ...processOptions,
-          name: this.getProcessUniqueName(),
+          ...moduleOptions,
+          name: this.getModuleUniqueName(),
         },
         this,
-        'processes',
+        'dependencies',
       );
     } else if (typeof options === 'string') {
-      process = Process.from(
+      module = Module.from(
         {
-          ...processOptions,
+          ...moduleOptions,
           name: options,
         },
         this,
-        'processes',
+        'dependencies',
       );
-    } else if (options instanceof Process) {
+    } else if (options instanceof Module) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      process = options;
-      Object.assign(process, relationOptions);
+      module = options;
+      Object.assign(module, relationOptions);
     } else {
-      process = Process.from(
+      module = Module.from(
         {
-          ...processOptions,
+          ...moduleOptions,
           ...options,
         },
         this,
-        'processes',
+        'dependencies',
       );
     }
-    this.processes.splice(index, 0, process);
-    return process;
+    this.dependencies.splice(index, 0, module);
+    return module;
   }
 
   /**
-   * 插入流程
-   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   * 插入模块
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  insertProcessAt(name: string, index: number): Process;
+  insertModuleInDependenciesAt(name: string, index: number): Module;
 
   /**
-   * 插入流程
-   * @param processOptions 流程参数
+   * 插入模块
+   * @param moduleOptions 模块参数
    */
-  insertProcessAt(processOptions: Partial<Process>, index: number): Process;
+  insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
 
   /**
-   * 插入流程
-   * @param process 已有的流程实例
+   * 插入模块
+   * @param module 已有的模块实例
    */
-  insertProcessAt(process: Process, index: number): Process;
+  insertModuleInDependenciesAt(module: Module, index: number): Module;
 
-  insertProcessAt(options: string | Partial<Process> | Process, index: number) {
-    const node = this._insertProcessAt(options as any, index);
+  insertModuleInDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+    const node = this._insertModuleInDependenciesAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'processes',
+      parentKey: 'dependencies',
     });
     return node;
   }
 
   /**
-   * 添加流程
+   * 添加模块
    * @internal
-   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  _addProcess(name?: string): Process;
+  _addModuleInDependencies(name?: string): Module;
 
   /**
-   * 添加流程
+   * 添加模块
    * @internal
-   * @param processOptions 流程参数
+   * @param moduleOptions 模块参数
    */
-  _addProcess(processOptions: Partial<Process>): Process;
+  _addModuleInDependencies(moduleOptions: Partial<Module>): Module;
 
   /**
-   * 添加流程
+   * 添加模块
    * @internal
-   * @param process 已有的流程实例
+   * @param module 已有的模块实例
    */
-  _addProcess(process: Process): Process;
+  _addModuleInDependencies(module: Module): Module;
 
-  _addProcess(options?: string | Partial<Process> | Process) {
-    const index = 0;
-    return this._insertProcessAt(options as any, index);
+  _addModuleInDependencies(options?: string | Partial<Module> | Module) {
+    const index = this.dependencies.length;
+    return this._insertModuleInDependenciesAt(options as any, index);
   }
 
   /**
-   * 添加流程
+   * 添加模块
    * @internal
-   * @param name 流程名称，如果不填会自动生成一个唯一名称
+   * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  addProcess(name?: string): Process;
+  addModuleInDependencies(name?: string): Module;
 
   /**
-   * 添加流程
-   * @param processOptions 流程参数
+   * 添加模块
+   * @param moduleOptions 模块参数
    */
-  addProcess(processOptions: Partial<Process>): Process;
+  addModuleInDependencies(moduleOptions: Partial<Module>): Module;
 
   /**
-   * 添加流程
-   * @param process 已有的流程实例
+   * 添加模块
+   * @param module 已有的模块实例
    */
-  addProcess(process: Process): Process;
+  addModuleInDependencies(module: Module): Module;
 
-  addProcess(options?: string | Partial<Process> | Process) {
-    const node = this._addProcess(options as any);
-    const index = this.processes.indexOf(node);
+  addModuleInDependencies(options?: string | Partial<Module> | Module) {
+    const node = this._addModuleInDependencies(options as any);
+    const index = this.dependencies.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'processes',
+      parentKey: 'dependencies',
     });
     return node;
   }
 
-  getRoleExistingNames(excludedList: Array<Role> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.roles as Role[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-  getRoleUniqueName(name = 'role1') {
-    return utils.unique(name, this.getRoleExistingNames(), undefined, true);
-  }
-
   /**
-   * 插入角色
+   * 插入连接器
    * @internal
-   * @param name 角色名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  _insertRoleAt(name: string, index: number): Role;
+  _insertConnectorInDependenciesAt(name: string, index: number): Connector;
 
   /**
-   * 插入角色
+   * 插入连接器
    * @internal
-   * @param roleOptions 角色参数
+   * @param connectorOptions 连接器参数
    */
-  _insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
+  _insertConnectorInDependenciesAt(connectorOptions: Partial<Connector>, index: number): Connector;
 
   /**
-   * 插入角色
+   * 插入连接器
    * @internal
-   * @param role 已有的角色实例
+   * @param connector 已有的连接器实例
    */
-  _insertRoleAt(role: Role, index: number): Role;
+  _insertConnectorInDependenciesAt(connector: Connector, index: number): Connector;
 
-  _insertRoleAt(options: string | Partial<Role> | Role, index: number) {
-    const roleOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'roles' };
-    let role: Role;
+  _insertConnectorInDependenciesAt(options: string | Partial<Connector> | Connector, index: number) {
+    const connectorOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+    let connector: Connector;
     if (!options) {
-      role = Role.from(
+      connector = Connector.from(
         {
-          ...roleOptions,
-          name: this.getRoleUniqueName(),
+          ...connectorOptions,
+          name: this.getConnectorUniqueName(),
         },
         this,
-        'roles',
+        'dependencies',
       );
     } else if (typeof options === 'string') {
-      role = Role.from(
+      connector = Connector.from(
         {
-          ...roleOptions,
+          ...connectorOptions,
           name: options,
         },
         this,
-        'roles',
+        'dependencies',
       );
-    } else if (options instanceof Role) {
+    } else if (options instanceof Connector) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      role = options;
-      Object.assign(role, relationOptions);
+      connector = options;
+      Object.assign(connector, relationOptions);
     } else {
-      role = Role.from(
+      connector = Connector.from(
         {
-          ...roleOptions,
+          ...connectorOptions,
           ...options,
         },
         this,
-        'roles',
+        'dependencies',
       );
     }
-    this.roles.splice(index, 0, role);
-    return role;
+    this.dependencies.splice(index, 0, connector);
+    return connector;
   }
 
   /**
-   * 插入角色
-   * @param name 角色名称，如果不填会自动生成一个唯一名称
+   * 插入连接器
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  insertRoleAt(name: string, index: number): Role;
+  insertConnectorInDependenciesAt(name: string, index: number): Connector;
 
   /**
-   * 插入角色
-   * @param roleOptions 角色参数
+   * 插入连接器
+   * @param connectorOptions 连接器参数
    */
-  insertRoleAt(roleOptions: Partial<Role>, index: number): Role;
+  insertConnectorInDependenciesAt(connectorOptions: Partial<Connector>, index: number): Connector;
 
   /**
-   * 插入角色
-   * @param role 已有的角色实例
+   * 插入连接器
+   * @param connector 已有的连接器实例
    */
-  insertRoleAt(role: Role, index: number): Role;
+  insertConnectorInDependenciesAt(connector: Connector, index: number): Connector;
 
-  insertRoleAt(options: string | Partial<Role> | Role, index: number) {
-    const node = this._insertRoleAt(options as any, index);
+  insertConnectorInDependenciesAt(options: string | Partial<Connector> | Connector, index: number) {
+    const node = this._insertConnectorInDependenciesAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'roles',
+      parentKey: 'dependencies',
     });
     return node;
   }
 
   /**
-   * 添加角色
+   * 添加连接器
    * @internal
-   * @param name 角色名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  _addRole(name?: string): Role;
+  _addConnectorInDependencies(name?: string): Connector;
 
   /**
-   * 添加角色
+   * 添加连接器
    * @internal
-   * @param roleOptions 角色参数
+   * @param connectorOptions 连接器参数
    */
-  _addRole(roleOptions: Partial<Role>): Role;
+  _addConnectorInDependencies(connectorOptions: Partial<Connector>): Connector;
 
   /**
-   * 添加角色
+   * 添加连接器
    * @internal
-   * @param role 已有的角色实例
+   * @param connector 已有的连接器实例
    */
-  _addRole(role: Role): Role;
+  _addConnectorInDependencies(connector: Connector): Connector;
 
-  _addRole(options?: string | Partial<Role> | Role) {
-    const index = this.roles.length;
-    return this._insertRoleAt(options as any, index);
+  _addConnectorInDependencies(options?: string | Partial<Connector> | Connector) {
+    const index = this.dependencies.length;
+    return this._insertConnectorInDependenciesAt(options as any, index);
   }
 
   /**
-   * 添加角色
+   * 添加连接器
    * @internal
-   * @param name 角色名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器名称，如果不填会自动生成一个唯一名称
    */
-  addRole(name?: string): Role;
+  addConnectorInDependencies(name?: string): Connector;
 
   /**
-   * 添加角色
-   * @param roleOptions 角色参数
+   * 添加连接器
+   * @param connectorOptions 连接器参数
    */
-  addRole(roleOptions: Partial<Role>): Role;
+  addConnectorInDependencies(connectorOptions: Partial<Connector>): Connector;
 
   /**
-   * 添加角色
-   * @param role 已有的角色实例
+   * 添加连接器
+   * @param connector 已有的连接器实例
    */
-  addRole(role: Role): Role;
+  addConnectorInDependencies(connector: Connector): Connector;
 
-  addRole(options?: string | Partial<Role> | Role) {
-    const node = this._addRole(options as any);
-    const index = this.roles.indexOf(node);
+  addConnectorInDependencies(options?: string | Partial<Connector> | Connector) {
+    const node = this._addConnectorInDependencies(options as any);
+    const index = this.dependencies.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'roles',
+      parentKey: 'dependencies',
     });
     return node;
   }
 
-  getModuleExistingNames(excludedList: Array<Module> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-  getModuleUniqueName(name = 'module1') {
-    return utils.unique(name, this.getModuleExistingNames(), undefined, false);
-  }
-
   /**
    * 插入模块
    * @internal
    * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  _insertModuleInDependenciesAt(name: string, index: number): Module;
+  _insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
 
   /**
    * 插入模块
    * @internal
    * @param moduleOptions 模块参数
    */
-  _insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+  _insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
 
   /**
    * 插入模块
    * @internal
    * @param module 已有的模块实例
    */
-  _insertModuleInDependenciesAt(module: Module, index: number): Module;
+  _insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
 
-  _insertModuleInDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+  _insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
     const moduleOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
+    const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
     let module: Module;
     if (!options) {
       module = Module.from(
@@ -2048,7 +2243,7 @@ export class App extends BaseNode {
           name: this.getModuleUniqueName(),
         },
         this,
-        'dependencies',
+        'interfaceDependencies',
       );
     } else if (typeof options === 'string') {
       module = Module.from(
@@ -2057,7 +2252,7 @@ export class App extends BaseNode {
           name: options,
         },
         this,
-        'dependencies',
+        'interfaceDependencies',
       );
     } else if (options instanceof Module) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -2070,10 +2265,10 @@ export class App extends BaseNode {
           ...options,
         },
         this,
-        'dependencies',
+        'interfaceDependencies',
       );
     }
-    this.dependencies.splice(index, 0, module);
+    this.interfaceDependencies.splice(index, 0, module);
     return module;
   }
 
@@ -2081,26 +2276,26 @@ export class App extends BaseNode {
    * 插入模块
    * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  insertModuleInDependenciesAt(name: string, index: number): Module;
+  insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
 
   /**
    * 插入模块
    * @param moduleOptions 模块参数
    */
-  insertModuleInDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+  insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
 
   /**
    * 插入模块
    * @param module 已有的模块实例
    */
-  insertModuleInDependenciesAt(module: Module, index: number): Module;
+  insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
 
-  insertModuleInDependenciesAt(options: string | Partial<Module> | Module, index: number) {
-    const node = this._insertModuleInDependenciesAt(options as any, index);
+  insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
+    const node = this._insertModuleInInterfaceDependenciesAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'interfaceDependencies',
     });
     return node;
   }
@@ -2110,25 +2305,25 @@ export class App extends BaseNode {
    * @internal
    * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  _addModuleInDependencies(name?: string): Module;
+  _addModuleInInterfaceDependencies(name?: string): Module;
 
   /**
    * 添加模块
    * @internal
    * @param moduleOptions 模块参数
    */
-  _addModuleInDependencies(moduleOptions: Partial<Module>): Module;
+  _addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
 
   /**
    * 添加模块
    * @internal
    * @param module 已有的模块实例
    */
-  _addModuleInDependencies(module: Module): Module;
+  _addModuleInInterfaceDependencies(module: Module): Module;
 
-  _addModuleInDependencies(options?: string | Partial<Module> | Module) {
-    const index = this.dependencies.length;
-    return this._insertModuleInDependenciesAt(options as any, index);
+  _addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
+    const index = this.interfaceDependencies.length;
+    return this._insertModuleInInterfaceDependenciesAt(options as any, index);
   }
 
   /**
@@ -2136,848 +2331,815 @@ export class App extends BaseNode {
    * @internal
    * @param name 模块名称，如果不填会自动生成一个唯一名称
    */
-  addModuleInDependencies(name?: string): Module;
+  addModuleInInterfaceDependencies(name?: string): Module;
 
   /**
    * 添加模块
    * @param moduleOptions 模块参数
    */
-  addModuleInDependencies(moduleOptions: Partial<Module>): Module;
+  addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
 
   /**
    * 添加模块
    * @param module 已有的模块实例
    */
-  addModuleInDependencies(module: Module): Module;
+  addModuleInInterfaceDependencies(module: Module): Module;
 
-  addModuleInDependencies(options?: string | Partial<Module> | Module) {
-    const node = this._addModuleInDependencies(options as any);
-    const index = this.dependencies.indexOf(node);
+  addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
+    const node = this._addModuleInInterfaceDependencies(options as any);
+    const index = this.interfaceDependencies.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'interfaceDependencies',
     });
     return node;
   }
 
   /**
-   * 插入连接器
+   * 插入调用接口的鉴权逻辑
    * @internal
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertConnectorInDependenciesAt(name: string, index: number): Connector;
+  _insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
 
   /**
-   * 插入连接器
+   * 插入调用接口的鉴权逻辑
    * @internal
-   * @param connectorOptions 连接器参数
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  _insertConnectorInDependenciesAt(connectorOptions: Partial<Connector>, index: number): Connector;
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 插入连接器
+   * 插入调用接口的鉴权逻辑
    * @internal
-   * @param connector 已有的连接器实例
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  _insertConnectorInDependenciesAt(connector: Connector, index: number): Connector;
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
 
-  _insertConnectorInDependenciesAt(options: string | Partial<Connector> | Connector, index: number) {
-    const connectorOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'dependencies' };
-    let connector: Connector;
+  _insertAuthLogicForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const authLogicForCallInterfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+    let authLogicForCallInterface: AuthLogicForCallInterface;
     if (!options) {
-      connector = Connector.from(
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
         {
-          ...connectorOptions,
-          name: this.getConnectorUniqueName(),
+          ...authLogicForCallInterfaceOptions,
+          name: this.getAuthLogicForCallInterfaceUniqueName(),
         },
         this,
-        'dependencies',
+        'authLogicsForCallInterface',
       );
     } else if (typeof options === 'string') {
-      connector = Connector.from(
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
         {
-          ...connectorOptions,
+          ...authLogicForCallInterfaceOptions,
           name: options,
         },
         this,
-        'dependencies',
+        'authLogicsForCallInterface',
       );
-    } else if (options instanceof Connector) {
+    } else if (options instanceof AuthLogicForCallInterface) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      connector = options;
-      Object.assign(connector, relationOptions);
+      authLogicForCallInterface = options;
+      Object.assign(authLogicForCallInterface, relationOptions);
     } else {
-      connector = Connector.from(
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
         {
-          ...connectorOptions,
+          ...authLogicForCallInterfaceOptions,
           ...options,
         },
         this,
-        'dependencies',
+        'authLogicsForCallInterface',
       );
     }
-    this.dependencies.splice(index, 0, connector);
-    return connector;
+    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+    return authLogicForCallInterface;
   }
 
   /**
-   * 插入连接器
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * 插入调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertConnectorInDependenciesAt(name: string, index: number): Connector;
+  insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
 
   /**
-   * 插入连接器
-   * @param connectorOptions 连接器参数
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  insertConnectorInDependenciesAt(connectorOptions: Partial<Connector>, index: number): Connector;
+  insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 插入连接器
-   * @param connector 已有的连接器实例
+   * 插入调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  insertConnectorInDependenciesAt(connector: Connector, index: number): Connector;
+  insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
 
-  insertConnectorInDependenciesAt(options: string | Partial<Connector> | Connector, index: number) {
-    const node = this._insertConnectorInDependenciesAt(options as any, index);
+  insertAuthLogicForCallInterfaceAt(
+    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
+    index: number,
+  ) {
+    const node = this._insertAuthLogicForCallInterfaceAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'authLogicsForCallInterface',
     });
     return node;
   }
 
   /**
-   * 添加连接器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addConnectorInDependencies(name?: string): Connector;
+  _addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
 
   /**
-   * 添加连接器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param connectorOptions 连接器参数
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  _addConnectorInDependencies(connectorOptions: Partial<Connector>): Connector;
+  _addAuthLogicForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 添加连接器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param connector 已有的连接器实例
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  _addConnectorInDependencies(connector: Connector): Connector;
+  _addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
 
-  _addConnectorInDependencies(options?: string | Partial<Connector> | Connector) {
-    const index = this.dependencies.length;
-    return this._insertConnectorInDependenciesAt(options as any, index);
+  _addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
+    const index = this.authLogicsForCallInterface.length;
+    return this._insertAuthLogicForCallInterfaceAt(options as any, index);
   }
 
   /**
-   * 添加连接器
+   * 添加调用接口的鉴权逻辑
    * @internal
-   * @param name 连接器名称，如果不填会自动生成一个唯一名称
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addConnectorInDependencies(name?: string): Connector;
+  addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
 
   /**
-   * 添加连接器
-   * @param connectorOptions 连接器参数
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
    */
-  addConnectorInDependencies(connectorOptions: Partial<Connector>): Connector;
+  addAuthLogicForCallInterface(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+  ): AuthLogicForCallInterface;
 
   /**
-   * 添加连接器
-   * @param connector 已有的连接器实例
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  addConnectorInDependencies(connector: Connector): Connector;
+  addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
 
-  addConnectorInDependencies(options?: string | Partial<Connector> | Connector) {
-    const node = this._addConnectorInDependencies(options as any);
-    const index = this.dependencies.indexOf(node);
+  addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
+    const node = this._addAuthLogicForCallInterface(options as any);
+    const index = this.authLogicsForCallInterface.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'dependencies',
+      parentKey: 'authLogicsForCallInterface',
     });
     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 模块名称，如果不填会自动生成一个唯一名称
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  _insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
+  _insertConnectionAt(name: string, index: number): Connection;
 
   /**
-   * 插入模块
+   * 插入连接
    * @internal
-   * @param moduleOptions 模块参数
+   * @param connectionOptions 连接参数
    */
-  _insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
 
   /**
-   * 插入模块
+   * 插入连接
    * @internal
-   * @param module 已有的模块实例
+   * @param connection 已有的连接实例
    */
-  _insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
+  _insertConnectionAt(connection: Connection, index: number): Connection;
 
-  _insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
-    const moduleOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'interfaceDependencies' };
-    let module: Module;
+  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const connectionOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'connections' };
+    let connection: Connection;
     if (!options) {
-      module = Module.from(
+      connection = Connection.from(
         {
-          ...moduleOptions,
-          name: this.getModuleUniqueName(),
+          ...connectionOptions,
+          name: this.getConnectionUniqueName(),
         },
         this,
-        'interfaceDependencies',
+        'connections',
       );
     } else if (typeof options === 'string') {
-      module = Module.from(
+      connection = Connection.from(
         {
-          ...moduleOptions,
+          ...connectionOptions,
           name: options,
         },
         this,
-        'interfaceDependencies',
+        'connections',
       );
-    } else if (options instanceof Module) {
+    } else if (options instanceof Connection) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      module = options;
-      Object.assign(module, relationOptions);
+      connection = options;
+      Object.assign(connection, relationOptions);
     } else {
-      module = Module.from(
+      connection = Connection.from(
         {
-          ...moduleOptions,
+          ...connectionOptions,
           ...options,
         },
         this,
-        'interfaceDependencies',
+        'connections',
       );
     }
-    this.interfaceDependencies.splice(index, 0, module);
-    return module;
+    this.connections.splice(index, 0, connection);
+    return connection;
   }
 
   /**
-   * 插入模块
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * 插入连接
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  insertModuleInInterfaceDependenciesAt(name: string, index: number): Module;
+  insertConnectionAt(name: string, index: number): Connection;
 
   /**
-   * 插入模块
-   * @param moduleOptions 模块参数
+   * 插入连接
+   * @param connectionOptions 连接参数
    */
-  insertModuleInInterfaceDependenciesAt(moduleOptions: Partial<Module>, index: number): Module;
+  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
 
   /**
-   * 插入模块
-   * @param module 已有的模块实例
+   * 插入连接
+   * @param connection 已有的连接实例
    */
-  insertModuleInInterfaceDependenciesAt(module: Module, index: number): Module;
+  insertConnectionAt(connection: Connection, index: number): Connection;
 
-  insertModuleInInterfaceDependenciesAt(options: string | Partial<Module> | Module, index: number) {
-    const node = this._insertModuleInInterfaceDependenciesAt(options as any, index);
+  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
+    const node = this._insertConnectionAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'interfaceDependencies',
+      parentKey: 'connections',
     });
     return node;
   }
 
   /**
-   * 添加模块
+   * 添加连接
    * @internal
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  _addModuleInInterfaceDependencies(name?: string): Module;
+  _addConnection(name?: string): Connection;
 
   /**
-   * 添加模块
+   * 添加连接
    * @internal
-   * @param moduleOptions 模块参数
+   * @param connectionOptions 连接参数
    */
-  _addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
+  _addConnection(connectionOptions: Partial<Connection>): Connection;
 
   /**
-   * 添加模块
+   * 添加连接
    * @internal
-   * @param module 已有的模块实例
+   * @param connection 已有的连接实例
    */
-  _addModuleInInterfaceDependencies(module: Module): Module;
+  _addConnection(connection: Connection): Connection;
 
-  _addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
-    const index = this.interfaceDependencies.length;
-    return this._insertModuleInInterfaceDependenciesAt(options as any, index);
+  _addConnection(options?: string | Partial<Connection> | Connection) {
+    const index = this.connections.length;
+    return this._insertConnectionAt(options as any, index);
   }
 
   /**
-   * 添加模块
+   * 添加连接
    * @internal
-   * @param name 模块名称，如果不填会自动生成一个唯一名称
+   * @param name 连接名称，如果不填会自动生成一个唯一名称
    */
-  addModuleInInterfaceDependencies(name?: string): Module;
+  addConnection(name?: string): Connection;
 
   /**
-   * 添加模块
-   * @param moduleOptions 模块参数
+   * 添加连接
+   * @param connectionOptions 连接参数
    */
-  addModuleInInterfaceDependencies(moduleOptions: Partial<Module>): Module;
+  addConnection(connectionOptions: Partial<Connection>): Connection;
 
   /**
-   * 添加模块
-   * @param module 已有的模块实例
+   * 添加连接
+   * @param connection 已有的连接实例
    */
-  addModuleInInterfaceDependencies(module: Module): Module;
+  addConnection(connection: Connection): Connection;
 
-  addModuleInInterfaceDependencies(options?: string | Partial<Module> | Module) {
-    const node = this._addModuleInInterfaceDependencies(options as any);
-    const index = this.interfaceDependencies.indexOf(node);
+  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: 'interfaceDependencies',
+      parentKey: 'connections',
     });
     return node;
   }
 
-  getAuthLogicForCallInterfaceExistingNames(excludedList: Array<AuthLogicForCallInterface> = []) {
+  getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.authLogicsForCallInterface as AuthLogicForCallInterface[]) || [])
+    return ((this.triggerLaunchers as TriggerLauncher[]) || [])
       .filter((item) => !excludedSet.has(item))
       .map((item) => item.name);
   }
-  getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
-    return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+  getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+    return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
   }
 
   /**
-   * 插入调用接口的鉴权逻辑
+   * 插入触发器启动器
    * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  _insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
+  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
 
   /**
-   * 插入调用接口的鉴权逻辑
+   * 插入触发器启动器
    * @internal
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  _insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-    index: number,
-  ): AuthLogicForCallInterface;
+  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
 
   /**
-   * 插入调用接口的鉴权逻辑
+   * 插入触发器启动器
    * @internal
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * @param triggerLauncher 已有的触发器启动器实例
    */
-  _insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-    index: number,
-  ): AuthLogicForCallInterface;
+  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
 
-  _insertAuthLogicForCallInterfaceAt(
-    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-    index: number,
-  ) {
-    const authLogicForCallInterfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
-    let authLogicForCallInterface: AuthLogicForCallInterface;
+  _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const triggerLauncherOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+    let triggerLauncher: TriggerLauncher;
     if (!options) {
-      authLogicForCallInterface = AuthLogicForCallInterface.from(
+      triggerLauncher = TriggerLauncher.from(
         {
-          ...authLogicForCallInterfaceOptions,
-          name: this.getAuthLogicForCallInterfaceUniqueName(),
+          ...triggerLauncherOptions,
+          name: this.getTriggerLauncherUniqueName(),
         },
         this,
-        'authLogicsForCallInterface',
+        'triggerLaunchers',
       );
     } else if (typeof options === 'string') {
-      authLogicForCallInterface = AuthLogicForCallInterface.from(
+      triggerLauncher = TriggerLauncher.from(
         {
-          ...authLogicForCallInterfaceOptions,
+          ...triggerLauncherOptions,
           name: options,
         },
         this,
-        'authLogicsForCallInterface',
+        'triggerLaunchers',
       );
-    } else if (options instanceof AuthLogicForCallInterface) {
+    } else if (options instanceof TriggerLauncher) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      authLogicForCallInterface = options;
-      Object.assign(authLogicForCallInterface, relationOptions);
+      triggerLauncher = options;
+      Object.assign(triggerLauncher, relationOptions);
     } else {
-      authLogicForCallInterface = AuthLogicForCallInterface.from(
+      triggerLauncher = TriggerLauncher.from(
         {
-          ...authLogicForCallInterfaceOptions,
+          ...triggerLauncherOptions,
           ...options,
         },
         this,
-        'authLogicsForCallInterface',
+        'triggerLaunchers',
       );
     }
-    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
-    return authLogicForCallInterface;
+    this.triggerLaunchers.splice(index, 0, triggerLauncher);
+    return triggerLauncher;
   }
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 插入触发器启动器
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
+  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * 插入触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-    index: number,
-  ): AuthLogicForCallInterface;
+  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * 插入触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
    */
-  insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-    index: number,
-  ): AuthLogicForCallInterface;
+  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
 
-  insertAuthLogicForCallInterfaceAt(
-    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-    index: number,
-  ) {
-    const node = this._insertAuthLogicForCallInterfaceAt(options as any, index);
+  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
+    const node = this._insertTriggerLauncherAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'authLogicsForCallInterface',
+      parentKey: 'triggerLaunchers',
     });
     return node;
   }
 
   /**
-   * 添加调用接口的鉴权逻辑
+   * 添加触发器启动器
    * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  _addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
+  _addTriggerLauncher(name?: string): TriggerLauncher;
 
   /**
-   * 添加调用接口的鉴权逻辑
+   * 添加触发器启动器
    * @internal
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  _addAuthLogicForCallInterface(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-  ): AuthLogicForCallInterface;
+  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
 
   /**
-   * 添加调用接口的鉴权逻辑
+   * 添加触发器启动器
    * @internal
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * @param triggerLauncher 已有的触发器启动器实例
    */
-  _addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
+  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
 
-  _addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
-    const index = this.authLogicsForCallInterface.length;
-    return this._insertAuthLogicForCallInterfaceAt(options as any, index);
+  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
+    const index = this.triggerLaunchers.length;
+    return this._insertTriggerLauncherAt(options as any, index);
   }
 
   /**
-   * 添加调用接口的鉴权逻辑
+   * 添加触发器启动器
    * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
    */
-  addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
+  addTriggerLauncher(name?: string): TriggerLauncher;
 
   /**
-   * 添加调用接口的鉴权逻辑
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * 添加触发器启动器
+   * @param triggerLauncherOptions 触发器启动器参数
    */
-  addAuthLogicForCallInterface(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-  ): AuthLogicForCallInterface;
+  addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
 
   /**
-   * 添加调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * 添加触发器启动器
+   * @param triggerLauncher 已有的触发器启动器实例
    */
-  addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
+  addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
 
-  addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
-    const node = this._addAuthLogicForCallInterface(options as any);
-    const index = this.authLogicsForCallInterface.indexOf(node);
+  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: 'authLogicsForCallInterface',
+      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 连接参数
+   * 删除数据源
+   * @param name 数据源名称
    */
-  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+  removeDataSource(name: string): void;
 
   /**
-   * 插入连接
-   * @internal
-   * @param connection 已有的连接实例
+   * 删除数据源
+   * @param dataSource 已有的数据源实例
    */
-  _insertConnectionAt(connection: Connection, index: number): Connection;
+  removeDataSource(dataSource: DataSource): void;
 
-  _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);
+  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 {
-      connection = Connection.from(
-        {
-          ...connectionOptions,
-          ...options,
-        },
-        this,
-        'connections',
-      );
+      dataSource = options;
     }
-    this.connections.splice(index, 0, connection);
-    return connection;
+    return dataSource.delete();
   }
 
-  /**
-   * 插入连接
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
-   */
-  insertConnectionAt(name: string, index: number): Connection;
+  __removeDataSource(dataSource: DataSource) {
+    const parentKey = dataSource.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: dataSource,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = dataSource.__v_raw || dataSource;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((t as any)[parentKey] === n) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
 
   /**
-   * 插入连接
-   * @param connectionOptions 连接参数
+   * 删除数据结构
+   * @param name 数据结构名称
    */
-  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+  removeStructure(name: string): void;
 
   /**
-   * 插入连接
-   * @param connection 已有的连接实例
+   * 删除数据结构
+   * @param structure 已有的数据结构实例
    */
-  insertConnectionAt(connection: Connection, index: number): Connection;
+  removeStructure(structure: Structure): void;
 
-  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const node = this._insertConnectionAt(options as any, index);
-    node.create({
-      index,
+  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: 'connections',
-    });
-    return node;
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: structure,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = structure.__v_raw || structure;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((t as any)[parentKey] === n) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
   }
 
   /**
-   * 添加连接
-   * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * 删除枚举
+   * @param name 枚举名称
    */
-  _addConnection(name?: string): Connection;
-
-  /**
-   * 添加连接
-   * @internal
-   * @param connectionOptions 连接参数
-   */
-  _addConnection(connectionOptions: Partial<Connection>): Connection;
+  removeEnum(name: string): void;
 
   /**
-   * 添加连接
-   * @internal
-   * @param connection 已有的连接实例
+   * 删除枚举
+   * @param enumeration 已有的枚举实例
    */
-  _addConnection(connection: Connection): Connection;
+  removeEnum(enumeration: Enum): void;
 
-  _addConnection(options?: string | Partial<Connection> | Connection) {
-    const index = this.connections.length;
-    return this._insertConnectionAt(options as any, index);
+  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();
   }
 
-  /**
-   * 添加连接
-   * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
-   */
-  addConnection(name?: string): Connection;
+  __removeEnum(enumeration: Enum) {
+    const parentKey = enumeration.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: enumeration,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = enumeration.__v_raw || enumeration;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((t as any)[parentKey] === n) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
 
   /**
-   * 添加连接
-   * @param connectionOptions 连接参数
+   * 删除逻辑
+   * @param name 逻辑名称
    */
-  addConnection(connectionOptions: Partial<Connection>): Connection;
+  removeLogic(name: string): void;
 
   /**
-   * 添加连接
-   * @param connection 已有的连接实例
+   * 删除逻辑
+   * @param logic 已有的逻辑实例
    */
-  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;
-  }
+  removeLogic(logic: Logic): void;
 
-  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);
+  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();
   }
 
   /**
-   * 插入触发器启动器
-   * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-   */
-  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
-
-  /**
-   * 插入触发器启动器
-   * @internal
-   * @param triggerLauncherOptions 触发器启动器参数
+   * 删除鉴权逻辑
+   * @param name 鉴权逻辑名称
    */
-  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+  removeAuthLogicInAuthLogics(name: string): void;
 
   /**
-   * 插入触发器启动器
-   * @internal
-   * @param triggerLauncher 已有的触发器启动器实例
+   * 删除鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+  removeAuthLogicInAuthLogics(authLogic: AuthLogic): void;
 
-  _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);
+  removeAuthLogicInAuthLogics(options: string | AuthLogic) {
+    let authLogic: AuthLogic;
+    if (typeof options === 'string') {
+      authLogic = (this.authLogics as AuthLogic[]).find((item) => item.name === options);
+      if (!authLogic) {
+        throw new Error('找不到鉴权逻辑 ' + options);
+      }
     } else {
-      triggerLauncher = TriggerLauncher.from(
-        {
-          ...triggerLauncherOptions,
-          ...options,
-        },
-        this,
-        'triggerLaunchers',
-      );
+      authLogic = options;
     }
-    this.triggerLaunchers.splice(index, 0, triggerLauncher);
-    return triggerLauncher;
+    return authLogic.delete();
   }
 
   /**
-   * 插入触发器启动器
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
+   * 删除调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称
    */
-  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
+  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name: string): void;
 
   /**
-   * 插入触发器启动器
-   * @param triggerLauncherOptions 触发器启动器参数
+   * 删除调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
+  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+  ): void;
 
-  /**
-   * 插入触发器启动器
-   * @param triggerLauncher 已有的触发器启动器实例
-   */
-  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
+  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(options: string | AuthLogicForCallInterface) {
+    let authLogicForCallInterface: AuthLogicForCallInterface;
+    if (typeof options === 'string') {
+      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
+        (item) => item.name === options,
+      );
+      if (!authLogicForCallInterface) {
+        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+      }
+    } else {
+      authLogicForCallInterface = options;
+    }
+    return authLogicForCallInterface.delete();
+  }
 
-  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-    const node = this._insertTriggerLauncherAt(options as any, index);
-    node.create({
-      index,
+  __removeLogic(logic: Logic) {
+    const parentKey = logic.parentKey;
+    const params: Params = {
       parentNode: this,
-      parentKey: 'triggerLaunchers',
-    });
-    return node;
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: logic,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = logic.__v_raw || logic;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((t as any)[parentKey] === n) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
   }
 
   /**
-   * 添加触发器启动器
-   * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-   */
-  _addTriggerLauncher(name?: string): TriggerLauncher;
-
-  /**
-   * 添加触发器启动器
-   * @internal
-   * @param triggerLauncherOptions 触发器启动器参数
+   * 删除覆写逻辑
+   * @param name 覆写逻辑名称
    */
-  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
+  removeOverriddenLogic(name: string): void;
 
   /**
-   * 添加触发器启动器
-   * @internal
-   * @param triggerLauncher 已有的触发器启动器实例
+   * 删除覆写逻辑
+   * @param overriddenLogic 已有的覆写逻辑实例
    */
-  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
-
-  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-    const index = this.triggerLaunchers.length;
-    return this._insertTriggerLauncherAt(options as any, index);
-  }
+  removeOverriddenLogic(overriddenLogic: OverriddenLogic): void;
 
-  /**
-   * 添加触发器启动器
-   * @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;
+  removeOverriddenLogic(options: string | OverriddenLogic) {
+    let overriddenLogic: OverriddenLogic;
     if (typeof options === 'string') {
-      dataSource = (this.dataSources as DataSource[]).find((item) => item.name === options);
-      if (!dataSource) {
-        throw new Error('找不到数据源 ' + options);
+      overriddenLogic = (this.overriddenLogics as OverriddenLogic[]).find((item) => item.name === options);
+      if (!overriddenLogic) {
+        throw new Error('找不到覆写逻辑 ' + options);
       }
     } else {
-      dataSource = options;
+      overriddenLogic = options;
     }
-    return dataSource.delete();
+    return overriddenLogic.delete();
   }
 
-  __removeDataSource(dataSource: DataSource) {
-    const parentKey = dataSource.parentKey;
+  __removeOverriddenLogic(overriddenLogic: OverriddenLogic) {
+    const parentKey = overriddenLogic.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: dataSource,
+      oldObject: overriddenLogic,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = dataSource.__v_raw || dataSource;
+      const n = overriddenLogic.__v_raw || overriddenLogic;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -2989,47 +3151,48 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除数据结构
-   * @param name 数据结构名称
+   * 删除接口
+   * @param name 接口名称
    */
-  removeStructure(name: string): void;
+  removeAbstractInterface(name: string): void;
 
   /**
-   * 删除数据结构
-   * @param structure 已有的数据结构实例
+   * 删除接口
+   * @param itface 已有的接口实例
    */
-  removeStructure(structure: Structure): void;
+  removeAbstractInterface(itface: AbstractInterface): void;
 
-  removeStructure(options: string | Structure) {
-    let structure: Structure;
+  removeAbstractInterface(options: string | AbstractInterface) {
+    let itface: AbstractInterface;
     if (typeof options === 'string') {
-      structure = (this.structures as Structure[]).find((item) => item.name === options);
-      if (!structure) {
-        throw new Error('找不到数据结构 ' + options);
+      itface = (this.interfaces as AbstractInterface[]).find((item) => item.name === options);
+      if (!itface) {
+        throw new Error('找不到接口 ' + options);
       }
     } else {
-      structure = options;
+      itface = options;
     }
-    return structure.delete();
+    return itface.delete();
   }
 
-  __removeStructure(structure: Structure) {
-    const parentKey = structure.parentKey;
+  __removeAbstractInterface(itface: AbstractInterface) {
+    const parentKey = itface.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: structure,
+      oldObject: itface,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = structure.__v_raw || structure;
+      const n = itface.__v_raw || itface;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3041,47 +3204,48 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除枚举
-   * @param name 枚举名称
+   * 删除前端
+   * @param name 前端名称
    */
-  removeEnum(name: string): void;
+  removeFrontend(name: string): void;
 
   /**
-   * 删除枚举
-   * @param enumeration 已有的枚举实例
+   * 删除前端
+   * @param frontend 已有的前端实例
    */
-  removeEnum(enumeration: Enum): void;
+  removeFrontend(frontend: Frontend): void;
 
-  removeEnum(options: string | Enum) {
-    let enumeration: Enum;
+  removeFrontend(options: string | Frontend) {
+    let frontend: Frontend;
     if (typeof options === 'string') {
-      enumeration = (this.enums as Enum[]).find((item) => item.name === options);
-      if (!enumeration) {
-        throw new Error('找不到枚举 ' + options);
+      frontend = (this.frontends as Frontend[]).find((item) => item.name === options);
+      if (!frontend) {
+        throw new Error('找不到前端 ' + options);
       }
     } else {
-      enumeration = options;
+      frontend = options;
     }
-    return enumeration.delete();
+    return frontend.delete();
   }
 
-  __removeEnum(enumeration: Enum) {
-    const parentKey = enumeration.parentKey;
+  __removeFrontend(frontend: Frontend) {
+    const parentKey = frontend.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: enumeration,
+      oldObject: frontend,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = enumeration.__v_raw || enumeration;
+      const n = frontend.__v_raw || frontend;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3093,72 +3257,101 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除逻辑
-   * @param name 逻辑名称
+   * 删除后端
+   * @param name 后端名称
    */
-  removeLogic(name: string): void;
+  removeBackend(name: string): void;
 
   /**
-   * 删除逻辑
-   * @param logic 已有的逻辑实例
+   * 删除后端
+   * @param backend 已有的后端实例
    */
-  removeLogic(logic: Logic): void;
+  removeBackend(backend: Backend): void;
 
-  removeLogic(options: string | Logic) {
-    let logic: Logic;
+  removeBackend(options: string | Backend) {
+    let backend: Backend;
     if (typeof options === 'string') {
-      logic = (this.logics as Logic[]).find((item) => item.name === options);
-      if (!logic) {
-        throw new Error('找不到逻辑 ' + options);
+      backend = this.backend;
+      if (!backend) {
+        throw new Error('找不到后端 ' + options);
       }
     } else {
-      logic = options;
+      backend = options;
     }
-    return logic.delete();
+    return backend.delete();
+  }
+
+  __removeBackend(backend: Backend) {
+    const parentKey = backend.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: backend,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      // @ts-ignore
+      const t = this.__v_raw || this;
+      // @ts-ignore
+      const n = backend.__v_raw || backend;
+      if (Array.isArray((t as any)[parentKey])) {
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((t as any)[parentKey] === n) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
   }
 
   /**
-   * 删除鉴权逻辑
-   * @param name 鉴权逻辑名称
+   * 删除流程
+   * @param name 流程名称
    */
-  removeAuthLogicInAuthLogics(name: string): void;
+  removeProcess(name: string): void;
 
   /**
-   * 删除鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 删除流程
+   * @param process 已有的流程实例
    */
-  removeAuthLogicInAuthLogics(authLogic: AuthLogic): void;
+  removeProcess(process: Process): void;
 
-  removeAuthLogicInAuthLogics(options: string | AuthLogic) {
-    let authLogic: AuthLogic;
+  removeProcess(options: string | Process) {
+    let process: Process;
     if (typeof options === 'string') {
-      authLogic = (this.authLogics as AuthLogic[]).find((item) => item.name === options);
-      if (!authLogic) {
-        throw new Error('找不到鉴权逻辑 ' + options);
+      process = (this.processes as Process[]).find((item) => item.name === options);
+      if (!process) {
+        throw new Error('找不到流程 ' + options);
       }
     } else {
-      authLogic = options;
+      process = options;
     }
-    return authLogic.delete();
+    return process.delete();
   }
 
-  __removeLogic(logic: Logic) {
-    const parentKey = logic.parentKey;
+  __removeProcess(process: Process) {
+    const parentKey = process.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: logic,
+      oldObject: process,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = logic.__v_raw || logic;
+      const n = process.__v_raw || process;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3170,47 +3363,48 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除覆写逻辑
-   * @param name 覆写逻辑名称
+   * 删除角色
+   * @param name 角色名称
    */
-  removeOverriddenLogic(name: string): void;
+  removeRole(name: string): void;
 
   /**
-   * 删除覆写逻辑
-   * @param overriddenLogic 已有的覆写逻辑实例
+   * 删除角色
+   * @param role 已有的角色实例
    */
-  removeOverriddenLogic(overriddenLogic: OverriddenLogic): void;
+  removeRole(role: Role): void;
 
-  removeOverriddenLogic(options: string | OverriddenLogic) {
-    let overriddenLogic: OverriddenLogic;
+  removeRole(options: string | Role) {
+    let role: Role;
     if (typeof options === 'string') {
-      overriddenLogic = (this.overriddenLogics as OverriddenLogic[]).find((item) => item.name === options);
-      if (!overriddenLogic) {
-        throw new Error('找不到覆写逻辑 ' + options);
+      role = (this.roles as Role[]).find((item) => item.name === options);
+      if (!role) {
+        throw new Error('找不到角色 ' + options);
       }
     } else {
-      overriddenLogic = options;
+      role = options;
     }
-    return overriddenLogic.delete();
+    return role.delete();
   }
 
-  __removeOverriddenLogic(overriddenLogic: OverriddenLogic) {
-    const parentKey = overriddenLogic.parentKey;
+  __removeRole(role: Role) {
+    const parentKey = role.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: overriddenLogic,
+      oldObject: role,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = overriddenLogic.__v_raw || overriddenLogic;
+      const n = role.__v_raw || role;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3222,72 +3416,48 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除接口
-   * @param name 接口名称
+   * 删除配置管理
+   * @param name 配置管理名称
    */
-  removeInterfaceInInterfaces(name: string): void;
+  removeConfiguration(name: string): void;
 
   /**
-   * 删除接口
-   * @param itface 已有的接口实例
+   * 删除配置管理
+   * @param configuration 已有的配置管理实例
    */
-  removeInterfaceInInterfaces(itface: Interface): void;
+  removeConfiguration(configuration: Configuration): void;
 
-  removeInterfaceInInterfaces(options: string | Interface) {
-    let itface: Interface;
+  removeConfiguration(options: string | Configuration) {
+    let configuration: Configuration;
     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();
-  }
-
-  /**
-   * 删除鉴权接口
-   * @param name 鉴权接口名称
-   */
-  removeAuthInterfaceInInterfaces(name: string): void;
-
-  /**
-   * 删除鉴权接口
-   * @param itface 已有的鉴权接口实例
-   */
-  removeAuthInterfaceInInterfaces(itface: AuthInterface): void;
-
-  removeAuthInterfaceInInterfaces(options: string | AuthInterface) {
-    let itface: AuthInterface;
-    if (typeof options === 'string') {
-      itface = (this.interfaces as AuthInterface[]).find((item) => item.name === options);
-      if (!itface) {
-        throw new Error('找不到鉴权接口 ' + options);
+      configuration = this.configuration;
+      if (!configuration) {
+        throw new Error('找不到配置管理 ' + options);
       }
     } else {
-      itface = options;
+      configuration = options;
     }
-    return itface.delete();
+    return configuration.delete();
   }
 
-  __removeInterface(itface: Interface) {
-    const parentKey = itface.parentKey;
+  __removeConfiguration(configuration: Configuration) {
+    const parentKey = configuration.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: itface,
+      oldObject: configuration,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = itface.__v_raw || itface;
+      const n = configuration.__v_raw || configuration;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3299,99 +3469,98 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除前端
-   * @param name 前端名称
+   * 删除模块
+   * @param name 模块名称
    */
-  removeFrontend(name: string): void;
+  removeModuleInDependencies(name: string): void;
 
   /**
-   * 删除前端
-   * @param frontend 已有的前端实例
+   * 删除模块
+   * @param module 已有的模块实例
    */
-  removeFrontend(frontend: Frontend): void;
+  removeModuleInDependencies(module: Module): void;
 
-  removeFrontend(options: string | Frontend) {
-    let frontend: Frontend;
+  removeModuleInDependencies(options: string | Module) {
+    let module: Module;
     if (typeof options === 'string') {
-      frontend = (this.frontends as Frontend[]).find((item) => item.name === options);
-      if (!frontend) {
-        throw new Error('找不到前端 ' + options);
+      module = (this.dependencies as Module[]).find((item) => item.name === options);
+      if (!module) {
+        throw new Error('找不到模块 ' + options);
       }
     } else {
-      frontend = options;
+      module = options;
     }
-    return frontend.delete();
+    return module.delete();
   }
 
-  __removeFrontend(frontend: Frontend) {
-    const parentKey = frontend.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: frontend,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = frontend.__v_raw || frontend;
-      if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+  /**
+   * 删除连接器
+   * @param name 连接器名称
+   */
+  removeConnectorInDependencies(name: string): void;
+
+  /**
+   * 删除连接器
+   * @param connector 已有的连接器实例
+   */
+  removeConnectorInDependencies(connector: Connector): void;
+
+  removeConnectorInDependencies(options: string | Connector) {
+    let connector: Connector;
+    if (typeof options === 'string') {
+      connector = (this.dependencies as Connector[]).find((item) => item.name === options);
+      if (!connector) {
+        throw new Error('找不到连接器 ' + options);
       }
+    } else {
+      connector = options;
     }
-    return params;
+    return connector.delete();
   }
 
   /**
-   * 删除后端
-   * @param name 后端名称
+   * 删除模块
+   * @param name 模块名称
    */
-  removeBackend(name: string): void;
+  removeModuleInInterfaceDependencies(name: string): void;
 
   /**
-   * 删除后端
-   * @param backend 已有的后端实例
+   * 删除模块
+   * @param module 已有的模块实例
    */
-  removeBackend(backend: Backend): void;
+  removeModuleInInterfaceDependencies(module: Module): void;
 
-  removeBackend(options: string | Backend) {
-    let backend: Backend;
+  removeModuleInInterfaceDependencies(options: string | Module) {
+    let module: Module;
     if (typeof options === 'string') {
-      backend = this.backend;
-      if (!backend) {
-        throw new Error('找不到后端 ' + options);
+      module = (this.interfaceDependencies as Module[]).find((item) => item.name === options);
+      if (!module) {
+        throw new Error('找不到模块 ' + options);
       }
     } else {
-      backend = options;
+      module = options;
     }
-    return backend.delete();
+    return module.delete();
   }
 
-  __removeBackend(backend: Backend) {
-    const parentKey = backend.parentKey;
+  __removeModule(module: Module) {
+    const parentKey = module.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: backend,
+      oldObject: module,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = backend.__v_raw || backend;
+      const n = module.__v_raw || module;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3403,47 +3572,48 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除流程
-   * @param name 流程名称
+   * 删除集成
+   * @param name 集成名称
    */
-  removeProcess(name: string): void;
+  removeIntegration(name: string): void;
 
   /**
-   * 删除流程
-   * @param process 已有的流程实例
+   * 删除集成
+   * @param integration 已有的集成实例
    */
-  removeProcess(process: Process): void;
+  removeIntegration(integration: Integration): void;
 
-  removeProcess(options: string | Process) {
-    let process: Process;
+  removeIntegration(options: string | Integration) {
+    let integration: Integration;
     if (typeof options === 'string') {
-      process = (this.processes as Process[]).find((item) => item.name === options);
-      if (!process) {
-        throw new Error('找不到流程 ' + options);
+      integration = this.integration;
+      if (!integration) {
+        throw new Error('找不到集成 ' + options);
       }
     } else {
-      process = options;
+      integration = options;
     }
-    return process.delete();
+    return integration.delete();
   }
 
-  __removeProcess(process: Process) {
-    const parentKey = process.parentKey;
+  __removeIntegration(integration: Integration) {
+    const parentKey = integration.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: process,
+      oldObject: integration,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = process.__v_raw || process;
+      const n = integration.__v_raw || integration;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3455,47 +3625,50 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除角色
-   * @param name 角色名称
+   * 删除调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称
    */
-  removeRole(name: string): void;
+  removeAuthLogicForCallInterface(name: string): void;
 
   /**
-   * 删除角色
-   * @param role 已有的角色实例
+   * 删除调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  removeRole(role: Role): void;
+  removeAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): void;
 
-  removeRole(options: string | Role) {
-    let role: Role;
+  removeAuthLogicForCallInterface(options: string | AuthLogicForCallInterface) {
+    let authLogicForCallInterface: AuthLogicForCallInterface;
     if (typeof options === 'string') {
-      role = (this.roles as Role[]).find((item) => item.name === options);
-      if (!role) {
-        throw new Error('找不到角色 ' + options);
+      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
+        (item) => item.name === options,
+      );
+      if (!authLogicForCallInterface) {
+        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
       }
     } else {
-      role = options;
+      authLogicForCallInterface = options;
     }
-    return role.delete();
+    return authLogicForCallInterface.delete();
   }
 
-  __removeRole(role: Role) {
-    const parentKey = role.parentKey;
+  __removeAuthLogic(authLogic: AuthLogic) {
+    const parentKey = authLogic.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: role,
+      oldObject: authLogic,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = role.__v_raw || role;
+      const n = authLogic.__v_raw || authLogic;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3507,47 +3680,48 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除配置管理
-   * @param name 配置管理名称
+   * 删除连接
+   * @param name 连接名称
    */
-  removeConfiguration(name: string): void;
+  removeConnection(name: string): void;
 
   /**
-   * 删除配置管理
-   * @param configuration 已有的配置管理实例
+   * 删除连接
+   * @param connection 已有的连接实例
    */
-  removeConfiguration(configuration: Configuration): void;
+  removeConnection(connection: Connection): void;
 
-  removeConfiguration(options: string | Configuration) {
-    let configuration: Configuration;
+  removeConnection(options: string | Connection) {
+    let connection: Connection;
     if (typeof options === 'string') {
-      configuration = this.configuration;
-      if (!configuration) {
-        throw new Error('找不到配置管理 ' + options);
+      connection = (this.connections as Connection[]).find((item) => item.name === options);
+      if (!connection) {
+        throw new Error('找不到连接 ' + options);
       }
     } else {
-      configuration = options;
+      connection = options;
     }
-    return configuration.delete();
+    return connection.delete();
   }
 
-  __removeConfiguration(configuration: Configuration) {
-    const parentKey = configuration.parentKey;
+  __removeConnection(connection: Connection) {
+    const parentKey = connection.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
       index: -1,
       object: null,
-      oldObject: configuration,
+      oldObject: connection,
     };
     if (parentKey) {
       params.parentKey = parentKey;
       // @ts-ignore
       const t = this.__v_raw || this;
       // @ts-ignore
-      const n = configuration.__v_raw || configuration;
+      const n = connection.__v_raw || connection;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -3559,270 +3733,10 @@ export class App extends BaseNode {
   }
 
   /**
-   * 删除模块
-   * @param name 模块名称
+   * 删除触发器启动器
+   * @param name 触发器启动器名称
    */
-  removeModuleInDependencies(name: string): void;
-
-  /**
-   * 删除模块
-   * @param module 已有的模块实例
-   */
-  removeModuleInDependencies(module: Module): void;
-
-  removeModuleInDependencies(options: string | Module) {
-    let module: Module;
-    if (typeof options === 'string') {
-      module = (this.dependencies as Module[]).find((item) => item.name === options);
-      if (!module) {
-        throw new Error('找不到模块 ' + options);
-      }
-    } else {
-      module = options;
-    }
-    return module.delete();
-  }
-
-  /**
-   * 删除连接器
-   * @param name 连接器名称
-   */
-  removeConnectorInDependencies(name: string): void;
-
-  /**
-   * 删除连接器
-   * @param connector 已有的连接器实例
-   */
-  removeConnectorInDependencies(connector: Connector): void;
-
-  removeConnectorInDependencies(options: string | Connector) {
-    let connector: Connector;
-    if (typeof options === 'string') {
-      connector = (this.dependencies as Connector[]).find((item) => item.name === options);
-      if (!connector) {
-        throw new Error('找不到连接器 ' + options);
-      }
-    } else {
-      connector = options;
-    }
-    return connector.delete();
-  }
-
-  /**
-   * 删除模块
-   * @param name 模块名称
-   */
-  removeModuleInInterfaceDependencies(name: string): void;
-
-  /**
-   * 删除模块
-   * @param module 已有的模块实例
-   */
-  removeModuleInInterfaceDependencies(module: Module): void;
-
-  removeModuleInInterfaceDependencies(options: string | Module) {
-    let module: Module;
-    if (typeof options === 'string') {
-      module = (this.interfaceDependencies as Module[]).find((item) => item.name === options);
-      if (!module) {
-        throw new Error('找不到模块 ' + options);
-      }
-    } else {
-      module = options;
-    }
-    return module.delete();
-  }
-
-  __removeModule(module: Module) {
-    const parentKey = module.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: module,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = module.__v_raw || module;
-      if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除集成
-   * @param name 集成名称
-   */
-  removeIntegration(name: string): void;
-
-  /**
-   * 删除集成
-   * @param integration 已有的集成实例
-   */
-  removeIntegration(integration: Integration): void;
-
-  removeIntegration(options: string | Integration) {
-    let integration: Integration;
-    if (typeof options === 'string') {
-      integration = this.integration;
-      if (!integration) {
-        throw new Error('找不到集成 ' + options);
-      }
-    } else {
-      integration = options;
-    }
-    return integration.delete();
-  }
-
-  __removeIntegration(integration: Integration) {
-    const parentKey = integration.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: integration,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = integration.__v_raw || integration;
-      if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称
-   */
-  removeAuthLogicForCallInterface(name: string): void;
-
-  /**
-   * 删除调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  removeAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): void;
-
-  removeAuthLogicForCallInterface(options: string | AuthLogicForCallInterface) {
-    let authLogicForCallInterface: AuthLogicForCallInterface;
-    if (typeof options === 'string') {
-      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
-        (item) => item.name === options,
-      );
-      if (!authLogicForCallInterface) {
-        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
-      }
-    } else {
-      authLogicForCallInterface = options;
-    }
-    return authLogicForCallInterface.delete();
-  }
-
-  __removeAuthLogic(authLogic: AuthLogic) {
-    const parentKey = authLogic.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: authLogic,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = authLogic.__v_raw || authLogic;
-      if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        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.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: connection,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = connection.__v_raw || connection;
-      if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除触发器启动器
-   * @param name 触发器启动器名称
-   */
-  removeTriggerLauncher(name: string): void;
+  removeTriggerLauncher(name: string): void;
 
   /**
    * 删除触发器启动器
@@ -3859,7 +3773,8 @@ export class App extends BaseNode {
       // @ts-ignore
       const n = triggerLauncher.__v_raw || triggerLauncher;
       if (Array.isArray((t as any)[parentKey])) {
-        const index = (t as any)[parentKey].indexOf(n);
+        // @ts-ignore
+        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
       } else if ((t as any)[parentKey] === n) {
@@ -4106,7 +4021,7 @@ export class App extends BaseNode {
     });
     this.dependencies.forEach((dep: Module) => {
       const { name, version, compilerInfoMap, frontends } = dep;
-      const prefixPath = compilerInfoMap?.js?.prefix;
+      const prefixPath = (compilerInfoMap as compilerInfoMapProps)?.js?.prefix;
       if (name) {
         (frontends || []).forEach((frontend) => {
           if (frontend.type === scope) {
@@ -4247,9 +4162,9 @@ export class App extends BaseNode {
 
   /* 判断接口是否有误，需要重新导出 */
 
-  getQualifiedInterface(interfaces: Interface[] = this.interfaces): MessageData[] {
+  getQualifiedInterface(interfaces: AbstractInterface[] = this.interfaces): MessageData[] {
     const errorList: MessageData[] = [];
-    interfaces.forEach((item: Interface) => {
+    (interfaces as unknown as Interface[]).forEach((item: Interface) => {
       const logic = this.logics.find((logic: Logic) => logic.name === item.originLogicName);
       const logicParamMap: any = {};
       logic.params.forEach((param) => {
@@ -4499,6 +4414,361 @@ export class App extends BaseNode {
     return ((this.dependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
   }
 
+  getAuthLogicForCallInterfaceExistingNames(excludedList: Array<AuthLogicForCallInterface> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.authLogicsForCallInterface as AuthLogicForCallInterface[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getAuthLogicForCallInterfaceUniqueName(name = 'authLogicForCallInterface1') {
+    return utils.unique(name, this.getAuthLogicForCallInterfaceExistingNames(), undefined, false);
+  }
+  //todo 替换生成
+  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, true);
+  }
+
+  /**
+   * 插入接口
+   * @internal
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  _insertInterfaceInInterfacesAt(name: string, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @internal
+   * @param itfaceOptions 接口参数
+   */
+  _insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @internal
+   * @param itface 已有的接口实例
+   */
+  _insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
+
+  _insertInterfaceInInterfacesAt(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 接口名称，如果不填会自动生成一个唯一名称
+   */
+  insertInterfaceInInterfacesAt(name: string, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @param itfaceOptions 接口参数
+   */
+  insertInterfaceInInterfacesAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+
+  /**
+   * 插入接口
+   * @param itface 已有的接口实例
+   */
+  insertInterfaceInInterfacesAt(itface: Interface, index: number): Interface;
+
+  insertInterfaceInInterfacesAt(options: string | Partial<Interface> | Interface, index: number) {
+    const node = this._insertInterfaceInInterfacesAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'interfaces',
+    });
+    return node;
+  }
+
+  /**
+   * 添加接口
+   * @internal
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  _addInterfaceInInterfaces(name?: string): Interface;
+
+  /**
+   * 添加接口
+   * @internal
+   * @param itfaceOptions 接口参数
+   */
+  _addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
+
+  /**
+   * 添加接口
+   * @internal
+   * @param itface 已有的接口实例
+   */
+  _addInterfaceInInterfaces(itface: Interface): Interface;
+
+  _addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
+    const index = 0;
+    return this._insertInterfaceInInterfacesAt(options as any, index);
+  }
+
+  /**
+   * 添加接口
+   * @internal
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   */
+  addInterfaceInInterfaces(name?: string): Interface;
+
+  /**
+   * 添加接口
+   * @param itfaceOptions 接口参数
+   */
+  addInterfaceInInterfaces(itfaceOptions: Partial<Interface>): Interface;
+
+  /**
+   * 添加接口
+   * @param itface 已有的接口实例
+   */
+  addInterfaceInInterfaces(itface: Interface): Interface;
+
+  addInterfaceInInterfaces(options?: string | Partial<Interface> | Interface) {
+    const node = this._addInterfaceInInterfaces(options as any);
+    const index = this.interfaces.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'interfaces',
+    });
+    return node;
+  }
+
+  /**
+   * 插入鉴权接口
+   * @internal
+   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
+
+  /**
+   * 插入鉴权接口
+   * @internal
+   * @param itfaceOptions 鉴权接口参数
+   */
+  _insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
+
+  /**
+   * 插入鉴权接口
+   * @internal
+   * @param itface 已有的鉴权接口实例
+   */
+  _insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
+
+  _insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
+    const itfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+    let itface: AuthInterface;
+    if (!options) {
+      itface = AuthInterface.from(
+        {
+          ...itfaceOptions,
+          name: this.getAuthInterfaceUniqueName(),
+        },
+        this,
+        'interfaces',
+      );
+    } else if (typeof options === 'string') {
+      itface = AuthInterface.from(
+        {
+          ...itfaceOptions,
+          name: options,
+        },
+        this,
+        'interfaces',
+      );
+    } else if (options instanceof AuthInterface) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      itface = options;
+      Object.assign(itface, relationOptions);
+    } else {
+      itface = AuthInterface.from(
+        {
+          ...itfaceOptions,
+          ...options,
+        },
+        this,
+        'interfaces',
+      );
+    }
+    this.interfaces.splice(index, 0, itface);
+    return itface;
+  }
+
+  /**
+   * 插入鉴权接口
+   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   */
+  insertAuthInterfaceInInterfacesAt(name: string, index: number): AuthInterface;
+
+  /**
+   * 插入鉴权接口
+   * @param itfaceOptions 鉴权接口参数
+   */
+  insertAuthInterfaceInInterfacesAt(itfaceOptions: Partial<AuthInterface>, index: number): AuthInterface;
+
+  /**
+   * 插入鉴权接口
+   * @param itface 已有的鉴权接口实例
+   */
+  insertAuthInterfaceInInterfacesAt(itface: AuthInterface, index: number): AuthInterface;
+
+  insertAuthInterfaceInInterfacesAt(options: string | Partial<AuthInterface> | AuthInterface, index: number) {
+    const node = this._insertAuthInterfaceInInterfacesAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'interfaces',
+    });
+    return node;
+  }
+
+  /**
+   * 添加鉴权接口
+   * @internal
+   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   */
+  _addAuthInterfaceInInterfaces(name?: string): AuthInterface;
+
+  /**
+   * 添加鉴权接口
+   * @internal
+   * @param itfaceOptions 鉴权接口参数
+   */
+  _addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
+
+  /**
+   * 添加鉴权接口
+   * @internal
+   * @param itface 已有的鉴权接口实例
+   */
+  _addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
+
+  _addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
+    const index = 0;
+    return this._insertAuthInterfaceInInterfacesAt(options as any, index);
+  }
+
+  /**
+   * 添加鉴权接口
+   * @internal
+   * @param name 鉴权接口名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthInterfaceInInterfaces(name?: string): AuthInterface;
+
+  /**
+   * 添加鉴权接口
+   * @param itfaceOptions 鉴权接口参数
+   */
+  addAuthInterfaceInInterfaces(itfaceOptions: Partial<AuthInterface>): AuthInterface;
+
+  /**
+   * 添加鉴权接口
+   * @param itface 已有的鉴权接口实例
+   */
+  addAuthInterfaceInInterfaces(itface: AuthInterface): AuthInterface;
+
+  addAuthInterfaceInInterfaces(options?: string | Partial<AuthInterface> | AuthInterface) {
+    const node = this._addAuthInterfaceInInterfaces(options as any);
+    const index = this.interfaces.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'interfaces',
+    });
+    return node;
+  }
+
+  /**
+   * 删除鉴权接口
+   * @param name 鉴权接口名称
+   */
+  removeAuthInterfaceInInterfaces(name: string): void;
+
+  /**
+   * 删除鉴权接口
+   * @param itface 已有的鉴权接口实例
+   */
+  removeAuthInterfaceInInterfaces(itface: AuthInterface): void;
+
+  removeAuthInterfaceInInterfaces(options: string | AuthInterface) {
+    let itface: AuthInterface;
+    if (typeof options === 'string') {
+      itface = (this.interfaces as AuthInterface[]).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;
+  }
   /** hank */
   // setConnector() {
   //   const [a, b, c, d, e, f] = this.connections;