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

package/src/concepts/Module__.ts

@@ -7,6 +7,7 @@ const moduleNameSpace = {
 type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies';
 import type { AuthInterface } from './AuthInterface__';
 import ConfigProperty from './ConfigProperty__';
+// import AuthLogic from './AuthLogic__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -22,16 +23,14 @@ import Structure from './Structure__';
 import Enum from './Enum__';
 import Logic from './Logic__';
 import Interface from './Interface__';
+import InterfaceFromExample from './InterfaceFromExample__';
 import View from './View__';
 import Variable from './Variable__';
 import Process from './Process__';
 import FrontendLibrary from './FrontendLibrary__';
 import Configuration from './Configuration__';
-import type AuthLogic from './AuthLogic__';
-import type AuthLogicForCallInterface from './AuthLogicForCallInterface__';
-import TriggerLauncher from './TriggerLauncher__';
-import Connection from './Connection__';
 import App from './App__';
+import AbstractInterface from './AbstractInterface__';
 
 /**
  * 模块
@@ -43,6 +42,9 @@ export class Module extends BaseNode {
   /** 类名 */
   static readonly ConceptName = 'Module';
 
+  /** 继承链 */
+  static readonly inheritanceChain = ['BaseNode'];
+
   /**
    * 产品概念
    */
@@ -113,7 +115,7 @@ export class Module extends BaseNode {
       javaTypes: Map<string, string>;
     }>;
     js?: { prefix: string };
-  };
+  } | Map<string, string>;
 
   /**
    * 数据源列表
@@ -156,14 +158,14 @@ export class Module extends BaseNode {
   logics: Array<Logic> = [];
 
   /**
-   * 接口列表
+   * interfaces
    */
   @property({
-    objectRef: 'Interface',
+    objectRef: 'Interface | InterfaceFromExample',
     isArray: true,
     defaultValue: [],
   })
-  interfaces: Array<Interface> = [];
+  interfaces: Array<Interface | InterfaceFromExample> = [];
 
   /**
    * 页面列表
@@ -214,46 +216,6 @@ export class Module extends BaseNode {
   // @ts-ignore
   configuration!: Configuration;
 
-  /**
-   * 暴露接口的接口鉴权
-   */
-  @property({
-    objectRef: 'AuthLogic',
-    isArray: true,
-    defaultValue: [],
-  })
-  authLogics: Array<AuthLogic> = [];
-
-  /**
-   * 调用接口的鉴权模板
-   */
-  @property({
-    objectRef: 'AuthLogicForCallInterface',
-    isArray: true,
-    defaultValue: [],
-  })
-  authLogicsForCallInterface: Array<AuthLogicForCallInterface> = [];
-
-  /**
-   * 触发器启动器列表
-   */
-  @property({
-    objectRef: 'TriggerLauncher',
-    isArray: true,
-    defaultValue: [],
-  })
-  triggerLaunchers: Array<TriggerLauncher> = [];
-
-  /**
-   * 连接列表
-   */
-  @property({
-    objectRef: 'Connection',
-    isArray: true,
-    defaultValue: [],
-  })
-  connections: Array<Connection> = [];
-
   /**
    * 祖先 App
    */
@@ -758,23 +720,23 @@ export class Module extends BaseNode {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertLogicInLogicsAt(name: string, index: number): Logic;
+  _insertLogicAt(name: string, index: number): Logic;
 
   /**
    * 插入逻辑
    * @internal
    * @param logicOptions 逻辑参数
    */
-  _insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
+  _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
    * 插入逻辑
    * @internal
    * @param logic 已有的逻辑实例
    */
-  _insertLogicInLogicsAt(logic: Logic, index: number): Logic;
+  _insertLogicAt(logic: Logic, index: number): Logic;
 
-  _insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
+  _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
     const logicOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'logics' };
     let logic: Logic;
@@ -818,22 +780,22 @@ export class Module extends BaseNode {
    * 插入逻辑
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertLogicInLogicsAt(name: string, index: number): Logic;
+  insertLogicAt(name: string, index: number): Logic;
 
   /**
    * 插入逻辑
    * @param logicOptions 逻辑参数
    */
-  insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
+  insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
    * 插入逻辑
    * @param logic 已有的逻辑实例
    */
-  insertLogicInLogicsAt(logic: Logic, index: number): Logic;
+  insertLogicAt(logic: Logic, index: number): Logic;
 
-  insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
-    const node = this._insertLogicInLogicsAt(options as any, index);
+  insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+    const node = this._insertLogicAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -847,25 +809,25 @@ export class Module extends BaseNode {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addLogicInLogics(name?: string): Logic;
+  _addLogic(name?: string): Logic;
 
   /**
    * 添加逻辑
    * @internal
    * @param logicOptions 逻辑参数
    */
-  _addLogicInLogics(logicOptions: Partial<Logic>): Logic;
+  _addLogic(logicOptions: Partial<Logic>): Logic;
 
   /**
    * 添加逻辑
    * @internal
    * @param logic 已有的逻辑实例
    */
-  _addLogicInLogics(logic: Logic): Logic;
+  _addLogic(logic: Logic): Logic;
 
-  _addLogicInLogics(options?: string | Partial<Logic> | Logic) {
+  _addLogic(options?: string | Partial<Logic> | Logic) {
     const index = 0;
-    return this._insertLogicInLogicsAt(options as any, index);
+    return this._insertLogicAt(options as any, index);
   }
 
   /**
@@ -873,22 +835,22 @@ export class Module extends BaseNode {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addLogicInLogics(name?: string): Logic;
+  addLogic(name?: string): Logic;
 
   /**
    * 添加逻辑
    * @param logicOptions 逻辑参数
    */
-  addLogicInLogics(logicOptions: Partial<Logic>): Logic;
+  addLogic(logicOptions: Partial<Logic>): Logic;
 
   /**
    * 添加逻辑
    * @param logic 已有的逻辑实例
    */
-  addLogicInLogics(logic: Logic): Logic;
+  addLogic(logic: Logic): Logic;
 
-  addLogicInLogics(options?: string | Partial<Logic> | Logic) {
-    const node = this._addLogicInLogics(options as any);
+  addLogic(options?: string | Partial<Logic> | Logic) {
+    const node = this._addLogic(options as any);
     const index = this.logics.indexOf(node);
     node.create({
       index,
@@ -898,187 +860,205 @@ export class Module extends BaseNode {
     return node;
   }
 
+  getInterfaceExistingNames(excludedList: Array<Interface> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getInterfaceUniqueName(name = 'Interface1') {
+    return utils.unique(name, this.getInterfaceExistingNames(), undefined, false);
+  }
+
   /**
-   * 插入鉴权逻辑
+   * 插入接口
    * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  _insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+  _insertInterfaceAt(name: string, index: number): Interface;
 
   /**
-   * 插入鉴权逻辑
+   * 插入接口
    * @internal
-   * @param authLogicOptions 鉴权逻辑参数
+   * @param itfaceOptions 接口参数
    */
-  _insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+  _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
 
   /**
-   * 插入鉴权逻辑
+   * 插入接口
    * @internal
-   * @param authLogic 已有的鉴权逻辑实例
+   * @param itface 已有的接口实例
    */
-  _insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+  _insertInterfaceAt(itface: Interface, index: number): Interface;
 
-  _insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
-    const authLogicOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'authLogics' };
-    let authLogic: AuthLogic;
+  _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+    const itfaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+    let itface: Interface;
     if (!options) {
-      // authLogic = AuthLogic.from({
-      //     ...authLogicOptions,
-      //     name: this.getAuthLogicUniqueName(),
-      // }, this, 'authLogics');
-      throw Error('请先调用from方法')
+      itface = Interface.from(
+        {
+          ...itfaceOptions,
+          name: this.getInterfaceUniqueName(),
+        },
+        this,
+        'interfaces',
+      );
     } else if (typeof options === 'string') {
-      // authLogic = AuthLogic.from({
-      //     ...authLogicOptions,
-      //     name: options,
-      // }, this, 'authLogics');
-      // FIXME : dont change
-      throw Error('请先调用from方法')
-    } else if (options.concept === 'AuthLogic') {
+      itface = Interface.from(
+        {
+          ...itfaceOptions,
+          name: options,
+        },
+        this,
+        'interfaces',
+      );
+    } else if (options instanceof Interface) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      authLogic = options as any;
-      Object.assign(authLogic, relationOptions);
+      itface = options;
+      Object.assign(itface, relationOptions);
     } else {
-      // authLogic = AuthLogic.from({
-      //     ...authLogicOptions,
-      //     ...options,
-      // }, this, 'authLogics');
-      throw Error('请先调用from方法')
+      itface = Interface.from(
+        {
+          ...itfaceOptions,
+          ...options,
+        },
+        this,
+        'interfaces',
+      );
     }
-    this.authLogics.splice(index, 0, authLogic);
-    return authLogic;
+    this.interfaces.splice(index, 0, itface);
+    return itface;
   }
 
   /**
-   * 插入鉴权逻辑
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 插入接口
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+  insertInterfaceAt(name: string, index: number): Interface;
 
   /**
-   * 插入鉴权逻辑
-   * @param authLogicOptions 鉴权逻辑参数
+   * 插入接口
+   * @param itfaceOptions 接口参数
    */
-  insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+  insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
 
   /**
-   * 插入鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 插入接口
+   * @param itface 已有的接口实例
    */
-  insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+  insertInterfaceAt(itface: Interface, index: number): Interface;
 
-  insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
-    const node = this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+    const node = this._insertInterfaceAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'authLogics',
+      parentKey: 'interfaces',
     });
     return node;
   }
 
   /**
-   * 添加鉴权逻辑
+   * 添加接口
    * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  _addAuthLogicInAuthLogics(name?: string): AuthLogic;
+  _addInterface(name?: string): Interface;
 
   /**
-   * 添加鉴权逻辑
+   * 添加接口
    * @internal
-   * @param authLogicOptions 鉴权逻辑参数
+   * @param itfaceOptions 接口参数
    */
-  _addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+  _addInterface(itfaceOptions: Partial<Interface>): Interface;
 
   /**
-   * 添加鉴权逻辑
+   * 添加接口
    * @internal
-   * @param authLogic 已有的鉴权逻辑实例
+   * @param itface 已有的接口实例
    */
-  _addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+  _addInterface(itface: Interface): Interface;
 
-  _addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
-    const index = this.authLogics.length;
-    return this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  _addInterface(options?: string | Partial<Interface> | Interface) {
+    const index = 0;
+    return this._insertInterfaceAt(options as any, index);
   }
 
   /**
-   * 添加鉴权逻辑
+   * 添加接口
    * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * @param name 接口名称，如果不填会自动生成一个唯一名称
    */
-  addAuthLogicInAuthLogics(name?: string): AuthLogic;
+  addInterface(name?: string): Interface;
 
   /**
-   * 添加鉴权逻辑
-   * @param authLogicOptions 鉴权逻辑参数
+   * 添加接口
+   * @param itfaceOptions 接口参数
    */
-  addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+  addInterface(itfaceOptions: Partial<Interface>): Interface;
 
   /**
-   * 添加鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 添加接口
+   * @param itface 已有的接口实例
    */
-  addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+  addInterface(itface: Interface): Interface;
 
-  addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
-    const node = this._addAuthLogicInAuthLogics(options as any);
-    const index = this.authLogics.indexOf(node);
+  addInterface(options?: string | Partial<Interface> | Interface) {
+    const node = this._addInterface(options as any);
+    const index = this.interfaces.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'authLogics',
+      parentKey: 'interfaces',
     });
     return node;
   }
 
-  getInterfaceExistingNames(excludedList: Array<Interface> = []) {
+  getInterfaceFromExampleExistingNames(excludedList: Array<InterfaceFromExample> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.interfaces as InterfaceFromExample[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
   }
-  getInterfaceUniqueName(name = 'Interface1') {
-    return utils.unique(name, this.getInterfaceExistingNames(), undefined, false);
+  getInterfaceFromExampleUniqueName(name = 'Interface1') {
+    return utils.unique(name, this.getInterfaceFromExampleExistingNames(), undefined, false);
   }
 
   /**
-   * 插入接口
+   * 插入由JSON生成接口
    * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * @param name 由JSON生成接口名称，如果不填会自动生成一个唯一名称
    */
-  _insertInterfaceAt(name: string, index: number): Interface;
+  _insertInterfaceFromExampleAt(name: string, index: number): InterfaceFromExample;
 
   /**
-   * 插入接口
+   * 插入由JSON生成接口
    * @internal
-   * @param itfaceOptions 接口参数
+   * @param itfaceOptions 由JSON生成接口参数
    */
-  _insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+  _insertInterfaceFromExampleAt(itfaceOptions: Partial<InterfaceFromExample>, index: number): InterfaceFromExample;
 
   /**
-   * 插入接口
+   * 插入由JSON生成接口
    * @internal
-   * @param itface 已有的接口实例
+   * @param itface 已有的由JSON生成接口实例
    */
-  _insertInterfaceAt(itface: Interface, index: number): Interface;
+  _insertInterfaceFromExampleAt(itface: InterfaceFromExample, index: number): InterfaceFromExample;
 
-  _insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
+  _insertInterfaceFromExampleAt(options: string | Partial<InterfaceFromExample> | InterfaceFromExample, index: number) {
     const itfaceOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'interfaces' };
-    let itface: Interface;
+    let itface: InterfaceFromExample;
     if (!options) {
-      itface = Interface.from(
+      itface = InterfaceFromExample.from(
         {
           ...itfaceOptions,
-          name: this.getInterfaceUniqueName(),
+          name: this.getInterfaceFromExampleUniqueName(),
         },
         this,
         'interfaces',
       );
     } else if (typeof options === 'string') {
-      itface = Interface.from(
+      itface = InterfaceFromExample.from(
         {
           ...itfaceOptions,
           name: options,
@@ -1086,12 +1066,12 @@ export class Module extends BaseNode {
         this,
         'interfaces',
       );
-    } else if (options instanceof Interface) {
+    } else if (options instanceof InterfaceFromExample) {
       options.ensureDelete(); // 同一实例不支持多处存在
       itface = options;
       Object.assign(itface, relationOptions);
     } else {
-      itface = Interface.from(
+      itface = InterfaceFromExample.from(
         {
           ...itfaceOptions,
           ...options,
@@ -1105,25 +1085,25 @@ export class Module extends BaseNode {
   }
 
   /**
-   * 插入接口
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * 插入由JSON生成接口
+   * @param name 由JSON生成接口名称，如果不填会自动生成一个唯一名称
    */
-  insertInterfaceAt(name: string, index: number): Interface;
+  insertInterfaceFromExampleAt(name: string, index: number): InterfaceFromExample;
 
   /**
-   * 插入接口
-   * @param itfaceOptions 接口参数
+   * 插入由JSON生成接口
+   * @param itfaceOptions 由JSON生成接口参数
    */
-  insertInterfaceAt(itfaceOptions: Partial<Interface>, index: number): Interface;
+  insertInterfaceFromExampleAt(itfaceOptions: Partial<InterfaceFromExample>, index: number): InterfaceFromExample;
 
   /**
-   * 插入接口
-   * @param itface 已有的接口实例
+   * 插入由JSON生成接口
+   * @param itface 已有的由JSON生成接口实例
    */
-  insertInterfaceAt(itface: Interface, index: number): Interface;
+  insertInterfaceFromExampleAt(itface: InterfaceFromExample, index: number): InterfaceFromExample;
 
-  insertInterfaceAt(options: string | Partial<Interface> | Interface, index: number) {
-    const node = this._insertInterfaceAt(options as any, index);
+  insertInterfaceFromExampleAt(options: string | Partial<InterfaceFromExample> | InterfaceFromExample, index: number) {
+    const node = this._insertInterfaceFromExampleAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -1133,52 +1113,52 @@ export class Module extends BaseNode {
   }
 
   /**
-   * 添加接口
+   * 添加由JSON生成接口
    * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * @param name 由JSON生成接口名称，如果不填会自动生成一个唯一名称
    */
-  _addInterface(name?: string): Interface;
+  _addInterfaceFromExample(name?: string): InterfaceFromExample;
 
   /**
-   * 添加接口
+   * 添加由JSON生成接口
    * @internal
-   * @param itfaceOptions 接口参数
+   * @param itfaceOptions 由JSON生成接口参数
    */
-  _addInterface(itfaceOptions: Partial<Interface>): Interface;
+  _addInterfaceFromExample(itfaceOptions: Partial<InterfaceFromExample>): InterfaceFromExample;
 
   /**
-   * 添加接口
+   * 添加由JSON生成接口
    * @internal
-   * @param itface 已有的接口实例
+   * @param itface 已有的由JSON生成接口实例
    */
-  _addInterface(itface: Interface): Interface;
+  _addInterfaceFromExample(itface: InterfaceFromExample): InterfaceFromExample;
 
-  _addInterface(options?: string | Partial<Interface> | Interface) {
+  _addInterfaceFromExample(options?: string | Partial<InterfaceFromExample> | InterfaceFromExample) {
     const index = 0;
-    return this._insertInterfaceAt(options as any, index);
+    return this._insertInterfaceFromExampleAt(options as any, index);
   }
 
   /**
-   * 添加接口
+   * 添加由JSON生成接口
    * @internal
-   * @param name 接口名称，如果不填会自动生成一个唯一名称
+   * @param name 由JSON生成接口名称，如果不填会自动生成一个唯一名称
    */
-  addInterface(name?: string): Interface;
+  addInterfaceFromExample(name?: string): InterfaceFromExample;
 
   /**
-   * 添加接口
-   * @param itfaceOptions 接口参数
+   * 添加由JSON生成接口
+   * @param itfaceOptions 由JSON生成接口参数
    */
-  addInterface(itfaceOptions: Partial<Interface>): Interface;
+  addInterfaceFromExample(itfaceOptions: Partial<InterfaceFromExample>): InterfaceFromExample;
 
   /**
-   * 添加接口
-   * @param itface 已有的接口实例
+   * 添加由JSON生成接口
+   * @param itface 已有的由JSON生成接口实例
    */
-  addInterface(itface: Interface): Interface;
+  addInterfaceFromExample(itface: InterfaceFromExample): InterfaceFromExample;
 
-  addInterface(options?: string | Partial<Interface> | Interface) {
-    const node = this._addInterface(options as any);
+  addInterfaceFromExample(options?: string | Partial<InterfaceFromExample> | InterfaceFromExample) {
+    const node = this._addInterfaceFromExample(options as any);
     const index = this.interfaces.indexOf(node);
     node.create({
       index,
@@ -1804,530 +1784,65 @@ export class Module extends BaseNode {
     return node;
   }
 
-  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);
-  }
-
-  /**
-   * 插入调用接口的鉴权逻辑
-   * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
-
   /**
-   * 插入调用接口的鉴权逻辑
-   * @internal
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * 删除数据源
+   * @param name 数据源名称
    */
-  _insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-    index: number,
-  ): AuthLogicForCallInterface;
+  removeDataSource(name: string): void;
 
   /**
-   * 插入调用接口的鉴权逻辑
-   * @internal
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * 删除数据源
+   * @param dataSource 已有的数据源实例
    */
-  _insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-    index: number,
-  ): AuthLogicForCallInterface;
+  removeDataSource(dataSource: DataSource): void;
 
-  _insertAuthLogicForCallInterfaceAt(
-    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-    index: number,
-  ) {
-    const authLogicForCallInterfaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
-    let authLogicForCallInterface: AuthLogicForCallInterface;
-    if (!options) {
-      throw Error('请先调用from方法创建AuthLogicForCallInterface实例')
-    } else if (typeof options === 'string') {
-      throw Error('请先调用from方法创建AuthLogicForCallInterface实例')
-      // FIXME : dont change
-    } else if (options.concept === 'AuthLogicForCallInterface') {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      authLogicForCallInterface = options as any;
-      Object.assign(authLogicForCallInterface, 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 {
-      throw Error('请先调用from方法创建AuthLogicForCallInterface实例')
+      dataSource = options;
     }
-    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
-    return authLogicForCallInterface;
+    return dataSource.delete();
   }
 
-  /**
-   * 插入调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  insertAuthLogicForCallInterfaceAt(name: string, index: number): AuthLogicForCallInterface;
-
-  /**
-   * 插入调用接口的鉴权逻辑
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
-   */
-  insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-    index: number,
-  ): AuthLogicForCallInterface;
-
-  /**
-   * 插入调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  insertAuthLogicForCallInterfaceAt(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-    index: number,
-  ): AuthLogicForCallInterface;
-
-  insertAuthLogicForCallInterfaceAt(
-    options: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface,
-    index: number,
-  ) {
-    const node = this._insertAuthLogicForCallInterfaceAt(options as any, index);
-    node.create({
-      index,
+  __removeDataSource(dataSource: DataSource) {
+    const parentKey = dataSource.parentKey;
+    const params: Params = {
       parentNode: this,
-      parentKey: 'authLogicsForCallInterface',
-    });
-    return node;
-  }
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
-   */
-  _addAuthLogicForCallInterface(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-  ): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  _addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
-
-  _addAuthLogicForCallInterface(options?: string | Partial<AuthLogicForCallInterface> | AuthLogicForCallInterface) {
-    const index = this.authLogicsForCallInterface.length;
-    return this._insertAuthLogicForCallInterfaceAt(options as any, index);
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: dataSource,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(dataSource);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === dataSource) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
   }
 
   /**
-   * 添加调用接口的鉴权逻辑
-   * @internal
-   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 删除数据结构
+   * @param name 数据结构名称
    */
-  addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
+  removeStructure(name: string): void;
 
   /**
-   * 添加调用接口的鉴权逻辑
-   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   * 删除数据结构
+   * @param structure 已有的数据结构实例
    */
-  addAuthLogicForCallInterface(
-    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
-  ): AuthLogicForCallInterface;
-
-  /**
-   * 添加调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  addAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): AuthLogicForCallInterface;
-
-  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: 'authLogicsForCallInterface',
-    });
-    return node;
-  }
-
-  getTriggerLauncherExistingNames(excludedList: Array<TriggerLauncher> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.triggerLaunchers as TriggerLauncher[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item.name);
-  }
-  getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
-    return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入触发器启动器
-   * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-   */
-  _insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
-
-  /**
-   * 插入触发器启动器
-   * @internal
-   * @param triggerLauncherOptions 触发器启动器参数
-   */
-  _insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
-
-  /**
-   * 插入触发器启动器
-   * @internal
-   * @param triggerLauncher 已有的触发器启动器实例
-   */
-  _insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
-
-  _insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-    const triggerLauncherOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
-    let triggerLauncher: TriggerLauncher;
-    if (!options) {
-      triggerLauncher = TriggerLauncher.from(
-        {
-          ...triggerLauncherOptions,
-          name: this.getTriggerLauncherUniqueName(),
-        },
-        this,
-        'triggerLaunchers',
-      );
-    } else if (typeof options === 'string') {
-      triggerLauncher = TriggerLauncher.from(
-        {
-          ...triggerLauncherOptions,
-          name: options,
-        },
-        this,
-        'triggerLaunchers',
-      );
-    } else if (options instanceof TriggerLauncher) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      triggerLauncher = options;
-      Object.assign(triggerLauncher, relationOptions);
-    } else {
-      triggerLauncher = TriggerLauncher.from(
-        {
-          ...triggerLauncherOptions,
-          ...options,
-        },
-        this,
-        'triggerLaunchers',
-      );
-    }
-    this.triggerLaunchers.splice(index, 0, triggerLauncher);
-    return triggerLauncher;
-  }
-
-  /**
-   * 插入触发器启动器
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-   */
-  insertTriggerLauncherAt(name: string, index: number): TriggerLauncher;
-
-  /**
-   * 插入触发器启动器
-   * @param triggerLauncherOptions 触发器启动器参数
-   */
-  insertTriggerLauncherAt(triggerLauncherOptions: Partial<TriggerLauncher>, index: number): TriggerLauncher;
-
-  /**
-   * 插入触发器启动器
-   * @param triggerLauncher 已有的触发器启动器实例
-   */
-  insertTriggerLauncherAt(triggerLauncher: TriggerLauncher, index: number): TriggerLauncher;
-
-  insertTriggerLauncherAt(options: string | Partial<TriggerLauncher> | TriggerLauncher, index: number) {
-    const node = this._insertTriggerLauncherAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'triggerLaunchers',
-    });
-    return node;
-  }
-
-  /**
-   * 添加触发器启动器
-   * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-   */
-  _addTriggerLauncher(name?: string): TriggerLauncher;
-
-  /**
-   * 添加触发器启动器
-   * @internal
-   * @param triggerLauncherOptions 触发器启动器参数
-   */
-  _addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
-
-  /**
-   * 添加触发器启动器
-   * @internal
-   * @param triggerLauncher 已有的触发器启动器实例
-   */
-  _addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
-
-  _addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-    const index = 0;
-    return this._insertTriggerLauncherAt(options as any, index);
-  }
-
-  /**
-   * 添加触发器启动器
-   * @internal
-   * @param name 触发器启动器名称，如果不填会自动生成一个唯一名称
-   */
-  addTriggerLauncher(name?: string): TriggerLauncher;
-
-  /**
-   * 添加触发器启动器
-   * @param triggerLauncherOptions 触发器启动器参数
-   */
-  addTriggerLauncher(triggerLauncherOptions: Partial<TriggerLauncher>): TriggerLauncher;
-
-  /**
-   * 添加触发器启动器
-   * @param triggerLauncher 已有的触发器启动器实例
-   */
-  addTriggerLauncher(triggerLauncher: TriggerLauncher): TriggerLauncher;
-
-  addTriggerLauncher(options?: string | Partial<TriggerLauncher> | TriggerLauncher) {
-    const node = this._addTriggerLauncher(options as any);
-    const index = this.triggerLaunchers.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'triggerLaunchers',
-    });
-    return node;
-  }
-
-  getConnectionExistingNames(excludedList: Array<Connection> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.connections as Connection[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-  getConnectionUniqueName(name = 'connection1') {
-    return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入连接
-   * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
-   */
-  _insertConnectionAt(name: string, index: number): Connection;
-
-  /**
-   * 插入连接
-   * @internal
-   * @param connectionOptions 连接参数
-   */
-  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
-
-  /**
-   * 插入连接
-   * @internal
-   * @param connection 已有的连接实例
-   */
-  _insertConnectionAt(connection: Connection, index: number): Connection;
-
-  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const connectionOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'connections' };
-    let connection: Connection;
-    if (!options) {
-      connection = Connection.from(
-        {
-          ...connectionOptions,
-          name: this.getConnectionUniqueName(),
-        },
-        this,
-        'connections',
-      );
-    } else if (typeof options === 'string') {
-      connection = Connection.from(
-        {
-          ...connectionOptions,
-          name: options,
-        },
-        this,
-        'connections',
-      );
-    } else if (options instanceof Connection) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      connection = options;
-      Object.assign(connection, relationOptions);
-    } else {
-      connection = Connection.from(
-        {
-          ...connectionOptions,
-          ...options,
-        },
-        this,
-        'connections',
-      );
-    }
-    this.connections.splice(index, 0, connection);
-    return connection;
-  }
-
-  /**
-   * 插入连接
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
-   */
-  insertConnectionAt(name: string, index: number): Connection;
-
-  /**
-   * 插入连接
-   * @param connectionOptions 连接参数
-   */
-  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
-
-  /**
-   * 插入连接
-   * @param connection 已有的连接实例
-   */
-  insertConnectionAt(connection: Connection, index: number): Connection;
-
-  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const node = this._insertConnectionAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'connections',
-    });
-    return node;
-  }
-
-  /**
-   * 添加连接
-   * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
-   */
-  _addConnection(name?: string): Connection;
-
-  /**
-   * 添加连接
-   * @internal
-   * @param connectionOptions 连接参数
-   */
-  _addConnection(connectionOptions: Partial<Connection>): Connection;
-
-  /**
-   * 添加连接
-   * @internal
-   * @param connection 已有的连接实例
-   */
-  _addConnection(connection: Connection): Connection;
-
-  _addConnection(options?: string | Partial<Connection> | Connection) {
-    const index = 0;
-    return this._insertConnectionAt(options as any, index);
-  }
-
-  /**
-   * 添加连接
-   * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
-   */
-  addConnection(name?: string): Connection;
-
-  /**
-   * 添加连接
-   * @param connectionOptions 连接参数
-   */
-  addConnection(connectionOptions: Partial<Connection>): Connection;
-
-  /**
-   * 添加连接
-   * @param connection 已有的连接实例
-   */
-  addConnection(connection: Connection): Connection;
-
-  addConnection(options?: string | Partial<Connection> | Connection) {
-    const node = this._addConnection(options as any);
-    const index = this.connections.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'connections',
-    });
-    return node;
-  }
-
-  /**
-   * 删除数据源
-   * @param name 数据源名称
-   */
-  removeDataSource(name: string): void;
-
-  /**
-   * 删除数据源
-   * @param dataSource 已有的数据源实例
-   */
-  removeDataSource(dataSource: DataSource): void;
-
-  removeDataSource(options: string | DataSource) {
-    let dataSource: DataSource;
-    if (typeof options === 'string') {
-      dataSource = (this.dataSources as DataSource[]).find((item) => item.name === options);
-      if (!dataSource) {
-        throw new Error('找不到数据源 ' + options);
-      }
-    } else {
-      dataSource = options;
-    }
-    return dataSource.delete();
-  }
-
-  __removeDataSource(dataSource: DataSource) {
-    const parentKey = dataSource.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: dataSource,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      if (Array.isArray((this as any)[parentKey])) {
-        const index = (this as any)[parentKey].indexOf(dataSource);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((this as any)[parentKey] === dataSource) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除数据结构
-   * @param name 数据结构名称
-   */
-  removeStructure(name: string): void;
-
-  /**
-   * 删除数据结构
-   * @param structure 已有的数据结构实例
-   */
-  removeStructure(structure: Structure): void;
+  removeStructure(structure: Structure): void;
 
   removeStructure(options: string | Structure) {
     let structure: Structure;
@@ -2417,15 +1932,15 @@ export class Module extends BaseNode {
    * 删除逻辑
    * @param name 逻辑名称
    */
-  removeLogicInLogics(name: string): void;
+  removeLogic(name: string): void;
 
   /**
    * 删除逻辑
    * @param logic 已有的逻辑实例
    */
-  removeLogicInLogics(logic: Logic): void;
+  removeLogic(logic: Logic): void;
 
-  removeLogicInLogics(options: string | Logic) {
+  removeLogic(options: string | Logic) {
     let logic: Logic;
     if (typeof options === 'string') {
       logic = (this.logics as Logic[]).find((item) => item.name === options);
@@ -2438,31 +1953,6 @@ export class Module extends BaseNode {
     return logic.delete();
   }
 
-  /**
-   * 删除鉴权逻辑
-   * @param name 鉴权逻辑名称
-   */
-  removeAuthLogicInAuthLogics(name: string): void;
-
-  /**
-   * 删除鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
-   */
-  removeAuthLogicInAuthLogics(authLogic: AuthLogic): void;
-
-  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 {
-      authLogic = options;
-    }
-    return authLogic.delete();
-  }
-
   __removeLogic(logic: Logic) {
     const parentKey = logic.parentKey;
     const params: Params = {
@@ -2511,7 +2001,55 @@ export class Module extends BaseNode {
     return itface.delete();
   }
 
-  __removeInterface(itface: Interface) {
+  __removeAbstractInterface(itface: AbstractInterface) {
+    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;
+  }
+
+  /**
+   * 删除由JSON生成接口
+   * @param name 由JSON生成接口名称
+   */
+  removeInterfaceFromExample(name: string): void;
+
+  /**
+   * 删除由JSON生成接口
+   * @param itface 已有的由JSON生成接口实例
+   */
+  removeInterfaceFromExample(itface: InterfaceFromExample): void;
+
+  removeInterfaceFromExample(options: string | InterfaceFromExample) {
+    let itface: InterfaceFromExample;
+    if (typeof options === 'string') {
+      itface = (this.interfaces as InterfaceFromExample[]).find((item) => item.name === options);
+      if (!itface) {
+        throw new Error('找不到由JSON生成接口 ' + options);
+      }
+    } else {
+      itface = options;
+    }
+    return itface.delete();
+  }
+
+  __removeInterfaceFromExample(itface: InterfaceFromExample) {
     const parentKey = itface.parentKey;
     const params: Params = {
       parentNode: this,
@@ -2774,152 +2312,6 @@ export class Module extends BaseNode {
     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;
-      if (Array.isArray((this as any)[parentKey])) {
-        const index = (this as any)[parentKey].indexOf(authLogic);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((this as any)[parentKey] === authLogic) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除触发器启动器
-   * @param name 触发器启动器名称
-   */
-  removeTriggerLauncher(name: string): void;
-
-  /**
-   * 删除触发器启动器
-   * @param triggerLauncher 已有的触发器启动器实例
-   */
-  removeTriggerLauncher(triggerLauncher: TriggerLauncher): void;
-
-  removeTriggerLauncher(options: string | TriggerLauncher) {
-    let triggerLauncher: TriggerLauncher;
-    if (typeof options === 'string') {
-      triggerLauncher = (this.triggerLaunchers as TriggerLauncher[]).find((item) => item.name === options);
-      if (!triggerLauncher) {
-        throw new Error('找不到触发器启动器 ' + options);
-      }
-    } else {
-      triggerLauncher = options;
-    }
-    return triggerLauncher.delete();
-  }
-
-  __removeTriggerLauncher(triggerLauncher: TriggerLauncher) {
-    const parentKey = triggerLauncher.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: triggerLauncher,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      if (Array.isArray((this as any)[parentKey])) {
-        const index = (this as any)[parentKey].indexOf(triggerLauncher);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((this as any)[parentKey] === triggerLauncher) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除连接
-   * @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;
-      if (Array.isArray((this as any)[parentKey])) {
-        const index = (this as any)[parentKey].indexOf(connection);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else if ((this as any)[parentKey] === connection) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
@@ -2995,7 +2387,7 @@ export class Module extends BaseNode {
   }
 
   delete() {
-    this.parentNode?.emit('collect:start', {
+    (this.parentNode as BaseNode)?.emit('collect:start', {
       actionMsg: '移除依赖库',
     });
     super.delete();
@@ -3014,7 +2406,7 @@ export class Module extends BaseNode {
     const dataSourceGroup = (this.parentNode as any)?.configuration?.getGroup('dataSource');
     if (this.dataSources && dataSourceGroup) {
       this.dataSources.forEach((datasource) => {
-        this.parentNode?.emit('clear:datasourceError', datasource as any);
+        (this.parentNode as BaseNode)?.emit('clear:datasourceError', datasource as any);
         try {
           dataSourceGroup.removeConfigProperty(datasource.name);
         } catch (e) {}
@@ -3029,7 +2421,7 @@ export class Module extends BaseNode {
     //     nextMainModule.softDelete({ index });
     // }
     // }
-    this.parentNode?.emit('collect:end');
+    (this.parentNode as BaseNode)?.emit('collect:end');
   }
 
   // 删除再添加 触发文件生成
@@ -3056,15 +2448,6 @@ export class Module extends BaseNode {
     }
   }
 
-  getAuthLogicExistingNames(excludedList: Array<AuthLogic> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.authLogics as AuthLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-
-  getAuthLogicUniqueName(name = 'authentication1') {
-    return utils.unique(name, this.getAuthLogicExistingNames(), undefined, true);
-  }
-
   setInterfaces(interfaces: Array<Interface | AuthInterface>) {
     this.update({
       interfaces,
@@ -3073,18 +2456,28 @@ export class Module extends BaseNode {
 
   // 获取数据结构被接口的引用关系
   getInterfaceStructureMap(): Map<Structure, Set<Interface>> {
-    const structureMap: Map<Structure, Set<Interface>> = new Map()
-    this.interfaces.forEach(itf => {
-      const structures = itf.getRefStructures(this.structures)
-      structures.forEach(s => {
+    const structureMap: Map<Structure, Set<Interface>> = new Map();
+    this.interfaces.forEach((itf) => {
+      const stashItf = itf instanceof Interface ? itf : (itf.inter as Interface);
+      const structures = stashItf.getRefStructures(this.structures);
+      structures.forEach((s) => {
         if (structureMap.has(s)) {
-          structureMap.get(s).add(itf)
+          structureMap.get(s).add(stashItf);
         } else {
-          structureMap.set(s, new Set([itf]))
+          structureMap.set(s, new Set([stashItf]));
         }
-      })
-    })
-    return structureMap
+      });
+    });
+    return structureMap;
+  }
+
+  /**
+   * 设置版本号
+   */
+  setVersion(version: string) {
+    this.update({
+      version,
+    });
   }
 
   //================================================================================