@lcap/nasl 3.4.0-alpha.1 → 3.4.0-beta.1

package/src/concepts/Module__.ts

@@ -5,18 +5,18 @@ const moduleNameSpace = {
   componentDependencies: 'components',
 };
 type ModuleKeyType = 'dependencies' | 'interfaceDependencies' | 'componentDependencies';
+import type { AuthInterface } from './AuthInterface__';
 import ConfigProperty from './ConfigProperty__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property } from '../decorators';
+import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import classMap from '../common/classMap';
 import DataSource from './DataSource__';
 import Structure from './Structure__';
 import Enum from './Enum__';
@@ -27,6 +27,8 @@ 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__';
@@ -34,135 +36,208 @@ import App from './App__';
 /**
  * 模块
  */
+@className
 @concept('模块')
+// @ts-ignore
 export class Module extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName = 'Module';
+
   /**
    * 产品概念
    */
-  @property()
-  concept: 'Module' | 'Connector' = 'Module';
+  // @ts-ignore
+  readonly concept!: 'Module' | 'Connector';
 
   /**
    * type
    */
   @property()
-  type: 'extension' | 'interface' | 'component' | 'connector' = undefined;
+  // @ts-ignore
+  type!: 'extension' | 'interface' | 'component' | 'connector' | 'customInterface';
 
   /**
    * version
    */
   @property()
-  version: string = undefined;
+  // @ts-ignore
+  version!: string;
 
   /**
    * 模块名称
    */
   @property()
-  name: string = undefined;
+  // @ts-ignore
+  name!: string;
 
   /**
    * 模块标题
    */
   @property()
-  title: string = undefined;
+  // @ts-ignore
+  title!: string;
 
   /**
    * 模块描述
    */
   @property()
-  description: string = undefined;
+  // @ts-ignore
+  description!: string;
 
   /**
    * provider
    */
   @property()
-  provider: string = undefined;
+  // @ts-ignore
+  provider!: string;
 
   /**
    * 外部语言依赖
    */
   @property()
-  externalDependencyMap: { maven?: Array<{ groupId: string; artifactId: string; version: string }> } = undefined;
+  // @ts-ignore
+  externalDependencyMap!: { maven?: Array<{ groupId: string; artifactId: string; version: string }> };
 
   /**
    * 外部语言依赖
    */
   @property()
-  compilerInfoMap: {
-    java?: Array<{ packageName: string; className: string; naslName: string; type: string; javaTypes: any }>;
+  // @ts-ignore
+  compilerInfoMap!: {
+    java?: Array<{
+      packageName: string;
+      className: string;
+      naslName: string;
+      type: string;
+      javaTypes: Map<string, string>;
+    }>;
     js?: { prefix: string };
-  } = undefined;
+  };
 
   /**
    * 数据源列表
    */
-  @property('DataSource')
+  @property({
+    objectRef: 'DataSource',
+    isArray: true,
+  })
   dataSources: Array<DataSource> = [];
 
   /**
    * 数据结构列表
    */
-  @property('Structure')
+  @property({
+    objectRef: 'Structure',
+    isArray: true,
+  })
   structures: Array<Structure> = [];
 
   /**
    * 枚举列表
    */
-  @property('Enum')
+  @property({
+    objectRef: 'Enum',
+    isArray: true,
+  })
   enums: Array<Enum> = [];
 
   /**
    * 逻辑列表
    */
-  @property('Logic')
+  @property({
+    objectRef: 'Logic',
+    isArray: true,
+  })
   logics: Array<Logic> = [];
 
   /**
    * 接口列表
    */
-  @property('Interface')
+  @property({
+    objectRef: 'Interface',
+    isArray: true,
+  })
   interfaces: Array<Interface> = [];
 
   /**
    * 页面列表
    */
-  @property('View')
+  @property({
+    objectRef: 'View',
+    isArray: true,
+  })
   views: Array<View> = [];
 
   /**
    * 变量列表
    */
-  @property('Variable')
+  @property({
+    objectRef: 'Variable',
+    isArray: true,
+  })
   frontendVariables: Array<Variable> = [];
 
   /**
    * 流程列表
    */
-  @property('Process')
+  @property({
+    objectRef: 'Process',
+    isArray: true,
+  })
   processes: Array<Process> = [];
 
   /**
-   * 端包列表
+   * 前端库列表
    */
-  @property('FrontendLibrary')
+  @property({
+    objectRef: 'FrontendLibrary',
+    isArray: true,
+  })
   frontends: Array<FrontendLibrary> = [];
 
   /**
    * 配置管理
    */
-  @property('Configuration')
-  configuration: Configuration = undefined;
+  @property({
+    objectRef: 'Configuration',
+  })
+  // @ts-ignore
+  configuration!: Configuration;
+
+  /**
+   * 暴露接口的接口鉴权
+   */
+  @property({
+    objectRef: 'AuthLogic',
+    isArray: true,
+  })
+  authLogics: Array<AuthLogic> = [];
+
+  /**
+   * 调用接口的鉴权模板
+   */
+  @property({
+    objectRef: 'AuthLogicForCallInterface',
+    isArray: true,
+  })
+  authLogicsForCallInterface: Array<AuthLogicForCallInterface> = [];
 
   /**
    * 触发器启动器列表
    */
-  @property('TriggerLauncher')
+  @property({
+    objectRef: 'TriggerLauncher',
+    isArray: true,
+  })
   triggerLaunchers: Array<TriggerLauncher> = [];
 
   /**
    * 连接列表
    */
-  @property('Connection')
+  @property({
+    objectRef: 'Connection',
+    isArray: true,
+  })
   connections: Array<Connection> = [];
 
   /**
@@ -180,9 +255,6 @@ export class Module extends BaseNode {
     super(source);
     super.subConstructor(source);
   }
-  getClassName() {
-    return 'Module';
-  }
 
   static from(source: any, parentNode?: any, parentKey?: string): Module {
     return super.from(source, parentNode, parentKey) as Module;
@@ -240,7 +312,7 @@ export class Module extends BaseNode {
           name: this.getDataSourceUniqueName(),
         },
         this,
-        'dataSources'
+        'dataSources',
       );
     } else if (typeof options === 'string') {
       dataSource = DataSource.from(
@@ -249,7 +321,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'dataSources'
+        'dataSources',
       );
     } else if (options instanceof DataSource) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -262,7 +334,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'dataSources'
+        'dataSources',
       );
     }
     this.dataSources.splice(index, 0, dataSource);
@@ -393,7 +465,7 @@ export class Module extends BaseNode {
           name: this.getStructureUniqueName(),
         },
         this,
-        'structures'
+        'structures',
       );
     } else if (typeof options === 'string') {
       structure = Structure.from(
@@ -402,7 +474,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'structures'
+        'structures',
       );
     } else if (options instanceof Structure) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -415,7 +487,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'structures'
+        'structures',
       );
     }
     this.structures.splice(index, 0, structure);
@@ -546,7 +618,7 @@ export class Module extends BaseNode {
           name: this.getEnumUniqueName(),
         },
         this,
-        'enums'
+        'enums',
       );
     } else if (typeof options === 'string') {
       enumeration = Enum.from(
@@ -555,7 +627,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'enums'
+        'enums',
       );
     } else if (options instanceof Enum) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -568,7 +640,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'enums'
+        'enums',
       );
     }
     this.enums.splice(index, 0, enumeration);
@@ -672,23 +744,23 @@ export class Module extends BaseNode {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertLogicAt(name: string, index: number): Logic;
+  _insertLogicInLogicsAt(name: string, index: number): Logic;
 
   /**
    * 插入逻辑
    * @internal
    * @param logicOptions 逻辑参数
    */
-  _insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+  _insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
    * 插入逻辑
    * @internal
    * @param logic 已有的逻辑实例
    */
-  _insertLogicAt(logic: Logic, index: number): Logic;
+  _insertLogicInLogicsAt(logic: Logic, index: number): Logic;
 
-  _insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
+  _insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
     const logicOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'logics' };
     let logic: Logic;
@@ -699,7 +771,7 @@ export class Module extends BaseNode {
           name: this.getLogicUniqueName(),
         },
         this,
-        'logics'
+        'logics',
       );
     } else if (typeof options === 'string') {
       logic = Logic.from(
@@ -708,7 +780,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'logics'
+        'logics',
       );
     } else if (options instanceof Logic) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -721,7 +793,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'logics'
+        'logics',
       );
     }
     this.logics.splice(index, 0, logic);
@@ -732,22 +804,22 @@ export class Module extends BaseNode {
    * 插入逻辑
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertLogicAt(name: string, index: number): Logic;
+  insertLogicInLogicsAt(name: string, index: number): Logic;
 
   /**
    * 插入逻辑
    * @param logicOptions 逻辑参数
    */
-  insertLogicAt(logicOptions: Partial<Logic>, index: number): Logic;
+  insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
 
   /**
    * 插入逻辑
    * @param logic 已有的逻辑实例
    */
-  insertLogicAt(logic: Logic, index: number): Logic;
+  insertLogicInLogicsAt(logic: Logic, index: number): Logic;
 
-  insertLogicAt(options: string | Partial<Logic> | Logic, index: number) {
-    const node = this._insertLogicAt(options as any, index);
+  insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
+    const node = this._insertLogicInLogicsAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -761,25 +833,25 @@ export class Module extends BaseNode {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addLogic(name?: string): Logic;
+  _addLogicInLogics(name?: string): Logic;
 
   /**
    * 添加逻辑
    * @internal
    * @param logicOptions 逻辑参数
    */
-  _addLogic(logicOptions: Partial<Logic>): Logic;
+  _addLogicInLogics(logicOptions: Partial<Logic>): Logic;
 
   /**
    * 添加逻辑
    * @internal
    * @param logic 已有的逻辑实例
    */
-  _addLogic(logic: Logic): Logic;
+  _addLogicInLogics(logic: Logic): Logic;
 
-  _addLogic(options?: string | Partial<Logic> | Logic) {
+  _addLogicInLogics(options?: string | Partial<Logic> | Logic) {
     const index = 0;
-    return this._insertLogicAt(options as any, index);
+    return this._insertLogicInLogicsAt(options as any, index);
   }
 
   /**
@@ -787,22 +859,22 @@ export class Module extends BaseNode {
    * @internal
    * @param name 逻辑名称，如果不填会自动生成一个唯一名称
    */
-  addLogic(name?: string): Logic;
+  addLogicInLogics(name?: string): Logic;
 
   /**
    * 添加逻辑
    * @param logicOptions 逻辑参数
    */
-  addLogic(logicOptions: Partial<Logic>): Logic;
+  addLogicInLogics(logicOptions: Partial<Logic>): Logic;
 
   /**
    * 添加逻辑
    * @param logic 已有的逻辑实例
    */
-  addLogic(logic: Logic): Logic;
+  addLogicInLogics(logic: Logic): Logic;
 
-  addLogic(options?: string | Partial<Logic> | Logic) {
-    const node = this._addLogic(options as any);
+  addLogicInLogics(options?: string | Partial<Logic> | Logic) {
+    const node = this._addLogicInLogics(options as any);
     const index = this.logics.indexOf(node);
     node.create({
       index,
@@ -812,6 +884,143 @@ export class Module extends BaseNode {
     return node;
   }
 
+  /**
+   * 插入鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @internal
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  _insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @internal
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  _insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+
+  _insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const authLogicOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+    let authLogic: AuthLogic;
+    if (!options) {
+      // authLogic = AuthLogic.from({
+      //     ...authLogicOptions,
+      //     name: this.getAuthLogicUniqueName(),
+      // }, this, 'authLogics');
+      throw Error('请先调用from方法')
+    } else if (typeof options === 'string') {
+      // authLogic = AuthLogic.from({
+      //     ...authLogicOptions,
+      //     name: options,
+      // }, this, 'authLogics');
+      // FIXME : dont change
+      throw Error('请先调用from方法')
+    } else if (options.concept === 'AuthLogic') {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      authLogic = options as any;
+      Object.assign(authLogic, relationOptions);
+    } else {
+      // authLogic = AuthLogic.from({
+      //     ...authLogicOptions,
+      //     ...options,
+      // }, this, 'authLogics');
+      throw Error('请先调用from方法')
+    }
+    this.authLogics.splice(index, 0, authLogic);
+    return authLogic;
+  }
+
+  /**
+   * 插入鉴权逻辑
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+
+  /**
+   * 插入鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+
+  insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const node = this._insertAuthLogicInAuthLogicsAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogics',
+    });
+    return node;
+  }
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  _addAuthLogicInAuthLogics(name?: string): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  _addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  _addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+
+  _addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const index = this.authLogics.length;
+    return this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  }
+
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthLogicInAuthLogics(name?: string): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+
+  addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const node = this._addAuthLogicInAuthLogics(options as any);
+    const index = this.authLogics.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogics',
+    });
+    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);
@@ -852,7 +1061,7 @@ export class Module extends BaseNode {
           name: this.getInterfaceUniqueName(),
         },
         this,
-        'interfaces'
+        'interfaces',
       );
     } else if (typeof options === 'string') {
       itface = Interface.from(
@@ -861,7 +1070,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'interfaces'
+        'interfaces',
       );
     } else if (options instanceof Interface) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -874,7 +1083,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'interfaces'
+        'interfaces',
       );
     }
     this.interfaces.splice(index, 0, itface);
@@ -1005,7 +1214,7 @@ export class Module extends BaseNode {
           name: this.getViewUniqueName(),
         },
         this,
-        'views'
+        'views',
       );
     } else if (typeof options === 'string') {
       view = View.from(
@@ -1014,7 +1223,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'views'
+        'views',
       );
     } else if (options instanceof View) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -1027,7 +1236,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'views'
+        'views',
       );
     }
     this.views.splice(index, 0, view);
@@ -1120,7 +1329,9 @@ export class Module extends BaseNode {
 
   getVarExistingNames(excludedList: Array<Variable> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontendVariables as Variable[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.frontendVariables as Variable[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
   }
   getVariableUniqueName(name = 'variable1') {
     return utils.unique(name, this.getVarExistingNames(), undefined, true);
@@ -1158,7 +1369,7 @@ export class Module extends BaseNode {
           name: this.getVariableUniqueName(),
         },
         this,
-        'frontendVariables'
+        'frontendVariables',
       );
     } else if (typeof options === 'string') {
       variable = Variable.from(
@@ -1167,7 +1378,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'frontendVariables'
+        'frontendVariables',
       );
     } else if (options instanceof Variable) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -1180,7 +1391,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'frontendVariables'
+        'frontendVariables',
       );
     }
     this.frontendVariables.splice(index, 0, variable);
@@ -1311,7 +1522,7 @@ export class Module extends BaseNode {
           name: this.getProcessUniqueName(),
         },
         this,
-        'processes'
+        'processes',
       );
     } else if (typeof options === 'string') {
       process = Process.from(
@@ -1320,7 +1531,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'processes'
+        'processes',
       );
     } else if (options instanceof Process) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -1333,7 +1544,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'processes'
+        'processes',
       );
     }
     this.processes.splice(index, 0, process);
@@ -1426,30 +1637,32 @@ export class Module extends BaseNode {
 
   getFrontendLibraryExistingNames(excludedList: Array<FrontendLibrary> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.frontends as FrontendLibrary[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.frontends as FrontendLibrary[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
   }
   getFrontendLibraryUniqueName(name = 'frontendLibrary1') {
     return utils.unique(name, this.getFrontendLibraryExistingNames(), undefined, false);
   }
 
   /**
-   * 插入端包
+   * 插入前端库
    * @internal
-   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   * @param name 前端库名称，如果不填会自动生成一个唯一名称
    */
   _insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
 
   /**
-   * 插入端包
+   * 插入前端库
    * @internal
-   * @param frontendLibraryOptions 端包参数
+   * @param frontendLibraryOptions 前端库参数
    */
   _insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
 
   /**
-   * 插入端包
+   * 插入前端库
    * @internal
-   * @param frontendLibrary 已有的端包实例
+   * @param frontendLibrary 已有的前端库实例
    */
   _insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
 
@@ -1464,7 +1677,7 @@ export class Module extends BaseNode {
           name: this.getFrontendLibraryUniqueName(),
         },
         this,
-        'frontends'
+        'frontends',
       );
     } else if (typeof options === 'string') {
       frontendLibrary = FrontendLibrary.from(
@@ -1473,7 +1686,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'frontends'
+        'frontends',
       );
     } else if (options instanceof FrontendLibrary) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -1486,7 +1699,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'frontends'
+        'frontends',
       );
     }
     this.frontends.splice(index, 0, frontendLibrary);
@@ -1494,20 +1707,20 @@ export class Module extends BaseNode {
   }
 
   /**
-   * 插入端包
-   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   * 插入前端库
+   * @param name 前端库名称，如果不填会自动生成一个唯一名称
    */
   insertFrontendLibraryAt(name: string, index: number): FrontendLibrary;
 
   /**
-   * 插入端包
-   * @param frontendLibraryOptions 端包参数
+   * 插入前端库
+   * @param frontendLibraryOptions 前端库参数
    */
   insertFrontendLibraryAt(frontendLibraryOptions: Partial<FrontendLibrary>, index: number): FrontendLibrary;
 
   /**
-   * 插入端包
-   * @param frontendLibrary 已有的端包实例
+   * 插入前端库
+   * @param frontendLibrary 已有的前端库实例
    */
   insertFrontendLibraryAt(frontendLibrary: FrontendLibrary, index: number): FrontendLibrary;
 
@@ -1522,23 +1735,23 @@ export class Module extends BaseNode {
   }
 
   /**
-   * 添加端包
+   * 添加前端库
    * @internal
-   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   * @param name 前端库名称，如果不填会自动生成一个唯一名称
    */
   _addFrontendLibrary(name?: string): FrontendLibrary;
 
   /**
-   * 添加端包
+   * 添加前端库
    * @internal
-   * @param frontendLibraryOptions 端包参数
+   * @param frontendLibraryOptions 前端库参数
    */
   _addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
 
   /**
-   * 添加端包
+   * 添加前端库
    * @internal
-   * @param frontendLibrary 已有的端包实例
+   * @param frontendLibrary 已有的前端库实例
    */
   _addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
 
@@ -1548,21 +1761,21 @@ export class Module extends BaseNode {
   }
 
   /**
-   * 添加端包
+   * 添加前端库
    * @internal
-   * @param name 端包名称，如果不填会自动生成一个唯一名称
+   * @param name 前端库名称，如果不填会自动生成一个唯一名称
    */
   addFrontendLibrary(name?: string): FrontendLibrary;
 
   /**
-   * 添加端包
-   * @param frontendLibraryOptions 端包参数
+   * 添加前端库
+   * @param frontendLibraryOptions 前端库参数
    */
   addFrontendLibrary(frontendLibraryOptions: Partial<FrontendLibrary>): FrontendLibrary;
 
   /**
-   * 添加端包
-   * @param frontendLibrary 已有的端包实例
+   * 添加前端库
+   * @param frontendLibrary 已有的前端库实例
    */
   addFrontendLibrary(frontendLibrary: FrontendLibrary): FrontendLibrary;
 
@@ -1577,9 +1790,168 @@ 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 调用接口的鉴权逻辑参数
+   */
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterfaceOptions: Partial<AuthLogicForCallInterface>,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @internal
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   */
+  _insertAuthLogicForCallInterfaceAt(
+    authLogicForCallInterface: AuthLogicForCallInterface,
+    index: number,
+  ): AuthLogicForCallInterface;
+
+  _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);
+    } else {
+      throw Error('请先调用from方法创建AuthLogicForCallInterface实例')
+    }
+    this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
+    return authLogicForCallInterface;
+  }
+
+  /**
+   * 插入调用接口的鉴权逻辑
+   * @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,
+      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);
+  }
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @internal
+   * @param name 调用接口的鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthLogicForCallInterface(name?: string): AuthLogicForCallInterface;
+
+  /**
+   * 添加调用接口的鉴权逻辑
+   * @param authLogicForCallInterfaceOptions 调用接口的鉴权逻辑参数
+   */
+  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);
+    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);
@@ -1617,7 +1989,7 @@ export class Module extends BaseNode {
           name: this.getTriggerLauncherUniqueName(),
         },
         this,
-        'triggerLaunchers'
+        'triggerLaunchers',
       );
     } else if (typeof options === 'string') {
       triggerLauncher = TriggerLauncher.from(
@@ -1626,7 +1998,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'triggerLaunchers'
+        'triggerLaunchers',
       );
     } else if (options instanceof TriggerLauncher) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -1639,7 +2011,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'triggerLaunchers'
+        'triggerLaunchers',
       );
     }
     this.triggerLaunchers.splice(index, 0, triggerLauncher);
@@ -1770,7 +2142,7 @@ export class Module extends BaseNode {
           name: this.getConnectionUniqueName(),
         },
         this,
-        'connections'
+        'connections',
       );
     } else if (typeof options === 'string') {
       connection = Connection.from(
@@ -1779,7 +2151,7 @@ export class Module extends BaseNode {
           name: options,
         },
         this,
-        'connections'
+        'connections',
       );
     } else if (options instanceof Connection) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -1792,7 +2164,7 @@ export class Module extends BaseNode {
           ...options,
         },
         this,
-        'connections'
+        'connections',
       );
     }
     this.connections.splice(index, 0, connection);
@@ -2031,15 +2403,15 @@ export class Module extends BaseNode {
    * 删除逻辑
    * @param name 逻辑名称
    */
-  removeLogic(name: string): void;
+  removeLogicInLogics(name: string): void;
 
   /**
    * 删除逻辑
    * @param logic 已有的逻辑实例
    */
-  removeLogic(logic: Logic): void;
+  removeLogicInLogics(logic: Logic): void;
 
-  removeLogic(options: string | Logic) {
+  removeLogicInLogics(options: string | Logic) {
     let logic: Logic;
     if (typeof options === 'string') {
       logic = (this.logics as Logic[]).find((item) => item.name === options);
@@ -2052,6 +2424,31 @@ 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 = {
@@ -2268,14 +2665,14 @@ export class Module extends BaseNode {
   }
 
   /**
-   * 删除端包
-   * @param name 端包名称
+   * 删除前端库
+   * @param name 前端库名称
    */
   removeFrontendLibrary(name: string): void;
 
   /**
-   * 删除端包
-   * @param frontendLibrary 已有的端包实例
+   * 删除前端库
+   * @param frontendLibrary 已有的前端库实例
    */
   removeFrontendLibrary(frontendLibrary: FrontendLibrary): void;
 
@@ -2284,7 +2681,7 @@ export class Module extends BaseNode {
     if (typeof options === 'string') {
       frontendLibrary = (this.frontends as FrontendLibrary[]).find((item) => item.name === options);
       if (!frontendLibrary) {
-        throw new Error('找不到端包 ' + options);
+        throw new Error('找不到前端库 ' + options);
       }
     } else {
       frontendLibrary = options;
@@ -2363,6 +2760,56 @@ 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 触发器启动器名称
@@ -2595,13 +3042,27 @@ 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,
+    });
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
   //================================================================================
 }
 
-classMap.Module = Module;
 export default Module;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑