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

package/src/concepts/Connector__.ts

@@ -1,29 +1,26 @@
+import View from './View__';
+import Frontend from './Frontend__';
+import ProcessElement from './ProcessElement__';
+import Process from './Process__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
+import Param from './Param__';
+import ConnectorTrigger from './ConnectorTrigger__';
+import Logic from './Logic__';
+import Namespace from './Namespace__';
+import AuthLogic from './AuthLogic__';
+import AuthLogicForCallInterface from './AuthLogicForCallInterface__';
 import Module from './Module__';
-import type Param from './Param__';
-import type Logic from './Logic__';
-import type ConnectorTrigger from './ConnectorTrigger__';
-import type Structure from './Structure__';
-import type Namespace from './Namespace__';
-import type AuthLogic from './AuthLogic__';
-import type AuthLogicForCallInterface from './AuthLogicForCallInterface__';
-import type TriggerLauncher from './TriggerLauncher__';
-import type Connection from './Connection__';
-import type View from './View__';
-import type ProcessElement from './ProcessElement__';
-import type App from './App__';
-import type Frontend from './Frontend__';
-import type Process from './Process__';
 
 /**
  * 连接器
@@ -32,7 +29,11 @@ import type Process from './Process__';
 export class Connector extends Module {
   /** 类名 */
   static readonly ConceptName: string = 'Connector';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['Module', 'BaseNode'];
 
@@ -42,18 +43,13 @@ export class Connector extends Module {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'Connector';
-
-  /**
-   * 连接器名称
-   */
-  @property()
-  name!: string;
-
   /**
    * connectorKind
    */
-  @property()
-  connectorKind!: string;
+  @property({
+    objectRef: '',
+  })
+  connectorKind: string;
 
   /**
    * 输入参数列表
@@ -65,16 +61,6 @@ export class Connector extends Module {
   })
   properties: Array<Param> = [];
 
-  /**
-   * 逻辑列表
-   */
-  @property({
-    objectRef: 'Logic',
-    isArray: true,
-    defaultValue: [],
-  })
-  logics: Array<Logic> = [];
-
   /**
    * 连接器触发器列表
    */
@@ -85,29 +71,13 @@ export class Connector extends Module {
   })
   triggers: Array<ConnectorTrigger> = [];
 
-  /**
-   * 数据结构列表
-   */
-  @property({
-    objectRef: 'Structure',
-    isArray: true,
-    defaultValue: [],
-  })
-  structures: Array<Structure> = [];
-
-  /**
-   * compilerInfoMap
-   */
-  @property()
-  compilerInfoMap!: Map<string, string>;
-
   /**
    * createLogic
    */
   @property({
     objectRef: 'Logic',
   })
-  createLogic!: undefined;
+  createLogic: Logic;
 
   /**
    * testConnectorLogic
@@ -115,13 +85,15 @@ export class Connector extends Module {
   @property({
     objectRef: 'Logic',
   })
-  testConnectorLogic!: undefined;
+  testConnectorLogic: Logic;
 
   /**
    * 预览图
    */
-  @property()
-  previewImg!: string;
+  @property({
+    objectRef: '',
+  })
+  previewImg: string;
 
   /**
    * 命名空间列表
@@ -154,68 +126,13 @@ export class Connector extends Module {
   authLogicsForCallInterface: Array<AuthLogicForCallInterface> = [];
 
   /**
-   * 触发器启动器列表
-   */
-  @property({
-    objectRef: 'TriggerLauncher',
-    isArray: true,
-    defaultValue: [],
-  })
-  triggerLaunchers: Array<TriggerLauncher> = [];
-
-  /**
-   * 连接列表
+   * isLocal
    */
   @property({
-    objectRef: 'Connection',
-    isArray: true,
-    defaultValue: [],
+    objectRef: '',
   })
-  connections: Array<Connection> = [];
-
-  /**
-   * isLocal
-   */
-  @property()
   isLocal: boolean = true;
 
-  /**
-   * 祖先 Module
-   */
-  get module() {
-    return this.getAncestor('Module') as Module;
-  }
-  /**
-   * 祖先 App
-   */
-  get app() {
-    return this.getAncestor('App') as App;
-  }
-  /**
-   * 祖先 View
-   */
-  get view() {
-    return this.getAncestor('View') as View;
-  }
-  /**
-   * 祖先 Frontend
-   */
-  get frontend() {
-    return this.getAncestor('Frontend') as Frontend;
-  }
-  /**
-   * 祖先 ProcessElement
-   */
-  get processElement() {
-    return this.getAncestor('ProcessElement') as ProcessElement;
-  }
-  /**
-   * 祖先 Process
-   */
-  get process() {
-    return this.getAncestor('Process') as Process;
-  }
-
   /**
    * @param source 需要合并的部分参数
    */
@@ -229,19 +146,6 @@ export class Connector extends Module {
     return super.from(source, parentNode, parentKey) as Connector;
   }
 
-  /**
-   * 设置连接器名称
-   */
-  setName(name: string) {
-    const object = {
-      name,
-    };
-    this.update({
-      ...object,
-      field: 'name',
-    });
-  }
-
   /**
    * 设置connectorKind
    */
@@ -266,18 +170,6 @@ export class Connector extends Module {
     });
   }
 
-  /**
-   * 设置逻辑列表
-   */
-  setLogics(logics: Array<Logic>) {
-    const object = {
-      logics,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
   /**
    * 设置连接器触发器列表
    */
@@ -290,34 +182,13 @@ export class Connector extends Module {
     });
   }
 
-  /**
-   * 设置数据结构列表
-   */
-  setStructures(structures: Array<Structure>) {
-    const object = {
-      structures,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
-  /**
-   * 设置compilerInfoMap
-   */
-  setCompilerInfoMap(compilerInfoMap: Map<string, string>) {
-    const object = {
-      compilerInfoMap,
-    };
-    this.update({
-      ...object,
-    });
-  }
-
   /**
    * 设置createLogic
    */
-  setCreateLogic(createLogic: undefined) {
+  setCreateLogic(createLogic: Logic) {
+    createLogic._delete();
+    const relationOptions = { parentNode: this, parentKey: 'createLogic' };
+    Object.assign(createLogic, relationOptions);
     const object = {
       createLogic,
     };
@@ -329,7 +200,10 @@ export class Connector extends Module {
   /**
    * 设置testConnectorLogic
    */
-  setTestConnectorLogic(testConnectorLogic: undefined) {
+  setTestConnectorLogic(testConnectorLogic: Logic) {
+    testConnectorLogic._delete();
+    const relationOptions = { parentNode: this, parentKey: 'testConnectorLogic' };
+    Object.assign(testConnectorLogic, relationOptions);
     const object = {
       testConnectorLogic,
     };
@@ -376,7 +250,7 @@ export class Connector extends Module {
 
   getParamExistingNames(excludedList: Array<Param> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.properties as Param[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.properties as Param[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getParamUniqueName(name = 'param1') {
     return utils.unique(name, this.getParamExistingNames(), undefined, false);
@@ -528,165 +402,11 @@ export class Connector extends Module {
     return node;
   }
 
-  getLogicExistingNames(excludedList: Array<Logic> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
-  }
-  getLogicUniqueName(name = 'logic1') {
-    return utils.unique(name, this.getLogicExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入逻辑
-   * @internal
-   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _insertLogicInLogicsAt(name: string, index: number): Logic;
-
-  /**
-   * 插入逻辑
-   * @internal
-   * @param logicOptions 逻辑参数
-   */
-  _insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
-
-  /**
-   * 插入逻辑
-   * @internal
-   * @param logic 已有的逻辑实例
-   */
-  _insertLogicInLogicsAt(logic: Logic, index: number): Logic;
-
-  _insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
-    const logicOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'logics' };
-    const Logic = getConceptConstructor('Logic');
-    let logic: Logic;
-    if (!options) {
-      logic = Logic.from(
-        {
-          ...logicOptions,
-          name: this.getLogicUniqueName(),
-        },
-        this,
-        'logics',
-      );
-    } else if (typeof options === 'string') {
-      logic = Logic.from(
-        {
-          ...logicOptions,
-          name: options,
-        },
-        this,
-        'logics',
-      );
-    } else if (asserts.isLogic(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      logic = options;
-      Object.assign(logic, relationOptions);
-    } else {
-      logic = Logic.from(
-        {
-          ...logicOptions,
-          ...options,
-        },
-        this,
-        'logics',
-      );
-    }
-    this.logics.splice(index, 0, logic);
-    return logic;
-  }
-
-  /**
-   * 插入逻辑
-   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  insertLogicInLogicsAt(name: string, index: number): Logic;
-
-  /**
-   * 插入逻辑
-   * @param logicOptions 逻辑参数
-   */
-  insertLogicInLogicsAt(logicOptions: Partial<Logic>, index: number): Logic;
-
-  /**
-   * 插入逻辑
-   * @param logic 已有的逻辑实例
-   */
-  insertLogicInLogicsAt(logic: Logic, index: number): Logic;
-
-  insertLogicInLogicsAt(options: string | Partial<Logic> | Logic, index: number) {
-    const node = this._insertLogicInLogicsAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'logics',
-    });
-    return node;
-  }
-
-  /**
-   * 添加逻辑
-   * @internal
-   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  _addLogicInLogics(name?: string): Logic;
-
-  /**
-   * 添加逻辑
-   * @internal
-   * @param logicOptions 逻辑参数
-   */
-  _addLogicInLogics(logicOptions: Partial<Logic>): Logic;
-
-  /**
-   * 添加逻辑
-   * @internal
-   * @param logic 已有的逻辑实例
-   */
-  _addLogicInLogics(logic: Logic): Logic;
-
-  _addLogicInLogics(options?: string | Partial<Logic> | Logic) {
-    const index = this.logics.length;
-    return this._insertLogicInLogicsAt(options as any, index);
-  }
-
-  /**
-   * 添加逻辑
-   * @internal
-   * @param name 逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  addLogicInLogics(name?: string): Logic;
-
-  /**
-   * 添加逻辑
-   * @param logicOptions 逻辑参数
-   */
-  addLogicInLogics(logicOptions: Partial<Logic>): Logic;
-
-  /**
-   * 添加逻辑
-   * @param logic 已有的逻辑实例
-   */
-  addLogicInLogics(logic: Logic): Logic;
-
-  addLogicInLogics(options?: string | Partial<Logic> | Logic) {
-    const node = this._addLogicInLogics(options as any);
-    const index = this.logics.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'logics',
-    });
-    return node;
-  }
-
   getConnectorTriggerExistingNames(excludedList: Array<ConnectorTrigger> = []) {
     const excludedSet = new Set(excludedList);
     return ((this.triggers as ConnectorTrigger[]) || [])
       .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+      .map((item) => item.name);
   }
   getConnectorTriggerUniqueName(name = 'connectorTrigger1') {
     return utils.unique(name, this.getConnectorTriggerExistingNames(), undefined, false);
@@ -838,286 +558,132 @@ export class Connector extends Module {
     return node;
   }
 
-  getStructureExistingNames(excludedList: Array<Structure> = []) {
+  getNamespaceExistingNames(excludedList: Array<Namespace> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.namespaces as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getStructureUniqueName(name = 'structure1') {
-    return utils.unique(name, this.getStructureExistingNames(), undefined, false);
+  getNamespaceUniqueName(name = 'namespace1') {
+    return utils.unique(name, this.getNamespaceExistingNames(), undefined, false);
   }
 
   /**
-   * 插入数据结构
+   * 插入命名空间
    * @internal
-   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
    */
-  _insertStructureAt(name: string, index: number): Structure;
+  _insertNamespaceAt(name: string, index: number): Namespace;
 
   /**
-   * 插入数据结构
+   * 插入命名空间
    * @internal
-   * @param structureOptions 数据结构参数
+   * @param namespaceOptions 命名空间参数
    */
-  _insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
+  _insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
 
   /**
-   * 插入数据结构
+   * 插入命名空间
    * @internal
-   * @param structure 已有的数据结构实例
+   * @param namespace 已有的命名空间实例
    */
-  _insertStructureAt(structure: Structure, index: number): Structure;
+  _insertNamespaceAt(namespace: Namespace, index: number): Namespace;
 
-  _insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
-    const structureOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'structures' };
-    const Structure = getConceptConstructor('Structure');
-    let structure: Structure;
+  _insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
+    const namespaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'namespaces' };
+    const Namespace = getConceptConstructor('Namespace');
+    let namespace: Namespace;
     if (!options) {
-      structure = Structure.from(
+      namespace = Namespace.from(
         {
-          ...structureOptions,
-          name: this.getStructureUniqueName(),
+          ...namespaceOptions,
+          name: this.getNamespaceUniqueName(),
         },
         this,
-        'structures',
+        'namespaces',
       );
     } else if (typeof options === 'string') {
-      structure = Structure.from(
+      namespace = Namespace.from(
         {
-          ...structureOptions,
+          ...namespaceOptions,
           name: options,
         },
         this,
-        'structures',
+        'namespaces',
       );
-    } else if (asserts.isStructure(options)) {
+    } else if (asserts.isNamespace(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      structure = options;
-      Object.assign(structure, relationOptions);
+      namespace = options;
+      Object.assign(namespace, relationOptions);
     } else {
-      structure = Structure.from(
+      namespace = Namespace.from(
         {
-          ...structureOptions,
+          ...namespaceOptions,
           ...options,
         },
         this,
-        'structures',
+        'namespaces',
       );
     }
-    this.structures.splice(index, 0, structure);
-    return structure;
+    this.namespaces.splice(index, 0, namespace);
+    return namespace;
   }
 
   /**
-   * 插入数据结构
-   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   * 插入命名空间
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
    */
-  insertStructureAt(name: string, index: number): Structure;
+  insertNamespaceAt(name: string, index: number): Namespace;
 
   /**
-   * 插入数据结构
-   * @param structureOptions 数据结构参数
+   * 插入命名空间
+   * @param namespaceOptions 命名空间参数
    */
-  insertStructureAt(structureOptions: Partial<Structure>, index: number): Structure;
+  insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
 
   /**
-   * 插入数据结构
-   * @param structure 已有的数据结构实例
+   * 插入命名空间
+   * @param namespace 已有的命名空间实例
    */
-  insertStructureAt(structure: Structure, index: number): Structure;
+  insertNamespaceAt(namespace: Namespace, index: number): Namespace;
 
-  insertStructureAt(options: string | Partial<Structure> | Structure, index: number) {
-    const node = this._insertStructureAt(options as any, index);
+  insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
+    const node = this._insertNamespaceAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'structures',
+      parentKey: 'namespaces',
     });
     return node;
   }
 
   /**
-   * 添加数据结构
+   * 添加命名空间
    * @internal
-   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
    */
-  _addStructure(name?: string): Structure;
+  _addNamespace(name?: string): Namespace;
 
   /**
-   * 添加数据结构
+   * 添加命名空间
    * @internal
-   * @param structureOptions 数据结构参数
+   * @param namespaceOptions 命名空间参数
    */
-  _addStructure(structureOptions: Partial<Structure>): Structure;
+  _addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
 
   /**
-   * 添加数据结构
+   * 添加命名空间
    * @internal
-   * @param structure 已有的数据结构实例
+   * @param namespace 已有的命名空间实例
    */
-  _addStructure(structure: Structure): Structure;
+  _addNamespace(namespace: Namespace): Namespace;
 
-  _addStructure(options?: string | Partial<Structure> | Structure) {
-    const index = this.structures.length;
-    return this._insertStructureAt(options as any, index);
+  _addNamespace(options?: string | Partial<Namespace> | Namespace) {
+    const index = this.namespaces.length;
+    return this._insertNamespaceAt(options as any, index);
   }
 
   /**
-   * 添加数据结构
-   * @internal
-   * @param name 数据结构名称，如果不填会自动生成一个唯一名称
-   */
-  addStructure(name?: string): Structure;
-
-  /**
-   * 添加数据结构
-   * @param structureOptions 数据结构参数
-   */
-  addStructure(structureOptions: Partial<Structure>): Structure;
-
-  /**
-   * 添加数据结构
-   * @param structure 已有的数据结构实例
-   */
-  addStructure(structure: Structure): Structure;
-
-  addStructure(options?: string | Partial<Structure> | Structure) {
-    const node = this._addStructure(options as any);
-    const index = this.structures.indexOf(node);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'structures',
-    });
-    return node;
-  }
-
-  getNamespaceExistingNames(excludedList: Array<Namespace> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.namespaces as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
-  }
-  getNamespaceUniqueName(name = 'namespace1') {
-    return utils.unique(name, this.getNamespaceExistingNames(), undefined, false);
-  }
-
-  /**
-   * 插入命名空间
-   * @internal
-   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-   */
-  _insertNamespaceAt(name: string, index: number): Namespace;
-
-  /**
-   * 插入命名空间
-   * @internal
-   * @param namespaceOptions 命名空间参数
-   */
-  _insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
-
-  /**
-   * 插入命名空间
-   * @internal
-   * @param namespace 已有的命名空间实例
-   */
-  _insertNamespaceAt(namespace: Namespace, index: number): Namespace;
-
-  _insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
-    const namespaceOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'namespaces' };
-    const Namespace = getConceptConstructor('Namespace');
-    let namespace: Namespace;
-    if (!options) {
-      namespace = Namespace.from(
-        {
-          ...namespaceOptions,
-          name: this.getNamespaceUniqueName(),
-        },
-        this,
-        'namespaces',
-      );
-    } else if (typeof options === 'string') {
-      namespace = Namespace.from(
-        {
-          ...namespaceOptions,
-          name: options,
-        },
-        this,
-        'namespaces',
-      );
-    } else if (asserts.isNamespace(options)) {
-      options.ensureDelete(); // 同一实例不支持多处存在
-      namespace = options;
-      Object.assign(namespace, relationOptions);
-    } else {
-      namespace = Namespace.from(
-        {
-          ...namespaceOptions,
-          ...options,
-        },
-        this,
-        'namespaces',
-      );
-    }
-    this.namespaces.splice(index, 0, namespace);
-    return namespace;
-  }
-
-  /**
-   * 插入命名空间
-   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-   */
-  insertNamespaceAt(name: string, index: number): Namespace;
-
-  /**
-   * 插入命名空间
-   * @param namespaceOptions 命名空间参数
-   */
-  insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
-
-  /**
-   * 插入命名空间
-   * @param namespace 已有的命名空间实例
-   */
-  insertNamespaceAt(namespace: Namespace, index: number): Namespace;
-
-  insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
-    const node = this._insertNamespaceAt(options as any, index);
-    node.create({
-      index,
-      parentNode: this,
-      parentKey: 'namespaces',
-    });
-    return node;
-  }
-
-  /**
-   * 添加命名空间
-   * @internal
-   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
-   */
-  _addNamespace(name?: string): Namespace;
-
-  /**
-   * 添加命名空间
-   * @internal
-   * @param namespaceOptions 命名空间参数
-   */
-  _addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
-
-  /**
-   * 添加命名空间
-   * @internal
-   * @param namespace 已有的命名空间实例
-   */
-  _addNamespace(namespace: Namespace): Namespace;
-
-  _addNamespace(options?: string | Partial<Namespace> | Namespace) {
-    const index = this.namespaces.length;
-    return this._insertNamespaceAt(options as any, index);
-  }
-
-  /**
-   * 添加命名空间
+   * 添加命名空间
    * @internal
    * @param name 命名空间名称，如果不填会自动生成一个唯一名称
    */
@@ -1146,852 +712,166 @@ export class Connector extends Module {
     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' };
-    const TriggerLauncher = getConceptConstructor('TriggerLauncher');
-    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 (asserts.isTriggerLauncher(options)) {
-      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> = []) {
+  getAuthLogicExistingNames(excludedList: Array<AuthLogic> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.connections as Connection[]) || [])
-      .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+    return ((this.authLogics as AuthLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-  getConnectionUniqueName(name = 'connection1') {
-    return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+  getAuthLogicUniqueName(name = 'authentication1') {
+    return utils.unique(name, this.getAuthLogicExistingNames(), undefined, false);
   }
 
   /**
-   * 插入连接
+   * 插入鉴权逻辑
    * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _insertConnectionAt(name: string, index: number): Connection;
+  _insertAuthLogicAt(name: string, index: number): AuthLogic;
 
   /**
-   * 插入连接
+   * 插入鉴权逻辑
    * @internal
-   * @param connectionOptions 连接参数
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  _insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+  _insertAuthLogicAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
 
   /**
-   * 插入连接
+   * 插入鉴权逻辑
    * @internal
-   * @param connection 已有的连接实例
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  _insertConnectionAt(connection: Connection, index: number): Connection;
+  _insertAuthLogicAt(authLogic: AuthLogic, index: number): AuthLogic;
 
-  _insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const connectionOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'connections' };
-    const Connection = getConceptConstructor('Connection');
-    let connection: Connection;
+  _insertAuthLogicAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const authLogicOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'authLogics' };
+    const AuthLogic = getConceptConstructor('AuthLogic');
+    let authLogic: AuthLogic;
     if (!options) {
-      connection = Connection.from(
+      authLogic = AuthLogic.from(
         {
-          ...connectionOptions,
-          name: this.getConnectionUniqueName(),
+          ...authLogicOptions,
+          name: this.getAuthLogicUniqueName(),
         },
         this,
-        'connections',
+        'authLogics',
       );
     } else if (typeof options === 'string') {
-      connection = Connection.from(
+      authLogic = AuthLogic.from(
         {
-          ...connectionOptions,
+          ...authLogicOptions,
           name: options,
         },
         this,
-        'connections',
+        'authLogics',
       );
-    } else if (asserts.isConnection(options)) {
+    } else if (asserts.isAuthLogic(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      connection = options;
-      Object.assign(connection, relationOptions);
+      authLogic = options;
+      Object.assign(authLogic, relationOptions);
     } else {
-      connection = Connection.from(
+      authLogic = AuthLogic.from(
         {
-          ...connectionOptions,
+          ...authLogicOptions,
           ...options,
         },
         this,
-        'connections',
+        'authLogics',
       );
     }
-    this.connections.splice(index, 0, connection);
-    return connection;
+    this.authLogics.splice(index, 0, authLogic);
+    return authLogic;
   }
 
   /**
-   * 插入连接
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * 插入鉴权逻辑
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  insertConnectionAt(name: string, index: number): Connection;
+  insertAuthLogicAt(name: string, index: number): AuthLogic;
 
   /**
-   * 插入连接
-   * @param connectionOptions 连接参数
+   * 插入鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  insertConnectionAt(connectionOptions: Partial<Connection>, index: number): Connection;
+  insertAuthLogicAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
 
   /**
-   * 插入连接
-   * @param connection 已有的连接实例
+   * 插入鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
    */
-  insertConnectionAt(connection: Connection, index: number): Connection;
+  insertAuthLogicAt(authLogic: AuthLogic, index: number): AuthLogic;
 
-  insertConnectionAt(options: string | Partial<Connection> | Connection, index: number) {
-    const node = this._insertConnectionAt(options as any, index);
+  insertAuthLogicAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
+    const node = this._insertAuthLogicAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'connections',
+      parentKey: 'authLogics',
     });
     return node;
   }
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @internal
-   * @param name 连接名称，如果不填会自动生成一个唯一名称
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
    */
-  _addConnection(name?: string): Connection;
+  _addAuthLogic(name?: string): AuthLogic;
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @internal
-   * @param connectionOptions 连接参数
+   * @param authLogicOptions 鉴权逻辑参数
    */
-  _addConnection(connectionOptions: Partial<Connection>): Connection;
+  _addAuthLogic(authLogicOptions: Partial<AuthLogic>): AuthLogic;
 
   /**
-   * 添加连接
+   * 添加鉴权逻辑
    * @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 输入参数名称
-   */
-  removeParam(name: string): void;
-
-  /**
-   * 删除输入参数
-   * @param param 已有的输入参数实例
-   */
-  removeParam(param: Param): void;
-
-  removeParam(options: string | Param) {
-    let param: Param;
-    if (typeof options === 'string') {
-      param = (this.properties as Param[]).find((item) => item.name === options);
-      if (!param) {
-        throw new Error('找不到输入参数 ' + options);
-      }
-    } else {
-      param = options;
-    }
-    return param.delete();
-  }
-
-  __removeParam(param: Param) {
-    const parentKey = param.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: param,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = param.__v_raw || param;
-      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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除逻辑
-   * @param name 逻辑名称
-   */
-  removeLogicInLogics(name: string): void;
-
-  /**
-   * 删除逻辑
-   * @param logic 已有的逻辑实例
-   */
-  removeLogicInLogics(logic: Logic): void;
-
-  removeLogicInLogics(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();
-  }
-
-  /**
-   * 删除逻辑
-   * @param name 逻辑名称
-   */
-  removeCreateLogic(name: string): void;
-
-  /**
-   * 删除逻辑
-   * @param createLogic 已有的逻辑实例
-   */
-  removeCreateLogic(createLogic: Logic): void;
-
-  removeCreateLogic(options: string | Logic) {
-    let createLogic: Logic;
-    if (typeof options === 'string') {
-      createLogic = this.createLogic;
-      if (!createLogic) {
-        throw new Error('找不到逻辑 ' + options);
-      }
-    } else {
-      createLogic = options;
-    }
-    return createLogic.delete();
-  }
-
-  /**
-   * 删除逻辑
-   * @param name 逻辑名称
-   */
-  removeTestConnectorLogic(name: string): void;
-
-  /**
-   * 删除逻辑
-   * @param testConnectorLogic 已有的逻辑实例
-   */
-  removeTestConnectorLogic(testConnectorLogic: Logic): void;
-
-  removeTestConnectorLogic(options: string | Logic) {
-    let testConnectorLogic: Logic;
-    if (typeof options === 'string') {
-      testConnectorLogic = this.testConnectorLogic;
-      if (!testConnectorLogic) {
-        throw new Error('找不到逻辑 ' + options);
-      }
-    } else {
-      testConnectorLogic = options;
-    }
-    return testConnectorLogic.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();
-  }
-
-  /**
-   * 删除调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称
-   */
-  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(name: string): void;
-
-  /**
-   * 删除调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
-   */
-  removeAuthLogicForCallInterfaceInAuthLogicsForCallInterface(
-    authLogicForCallInterface: AuthLogicForCallInterface,
-  ): void;
-
-  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();
-  }
-
-  __removeLogic(logic: Logic) {
-    const parentKey = logic.parentKey;
-    const params: Params = {
-      parentNode: this,
-      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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除连接器触发器
-   * @param name 连接器触发器名称
-   */
-  removeConnectorTrigger(name: string): void;
-
-  /**
-   * 删除连接器触发器
-   * @param connectorTrigger 已有的连接器触发器实例
-   */
-  removeConnectorTrigger(connectorTrigger: ConnectorTrigger): void;
-
-  removeConnectorTrigger(options: string | ConnectorTrigger) {
-    let connectorTrigger: ConnectorTrigger;
-    if (typeof options === 'string') {
-      connectorTrigger = (this.triggers as ConnectorTrigger[]).find((item) => item.name === options);
-      if (!connectorTrigger) {
-        throw new Error('找不到连接器触发器 ' + options);
-      }
-    } else {
-      connectorTrigger = options;
-    }
-    return connectorTrigger.delete();
-  }
-
-  __removeConnectorTrigger(connectorTrigger: ConnectorTrigger) {
-    const parentKey = connectorTrigger.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: connectorTrigger,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = connectorTrigger.__v_raw || connectorTrigger;
-      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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除数据结构
-   * @param name 数据结构名称
-   */
-  removeStructure(name: string): void;
-
-  /**
-   * 删除数据结构
-   * @param structure 已有的数据结构实例
-   */
-  removeStructure(structure: Structure): void;
-
-  removeStructure(options: string | Structure) {
-    let structure: Structure;
-    if (typeof options === 'string') {
-      structure = (this.structures as Structure[]).find((item) => item.name === options);
-      if (!structure) {
-        throw new Error('找不到数据结构 ' + options);
-      }
-    } else {
-      structure = options;
-    }
-    return structure.delete();
-  }
-
-  __removeStructure(structure: Structure) {
-    const parentKey = structure.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: structure,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除命名空间
-   * @param name 命名空间名称
-   */
-  removeNamespace(name: string): void;
-
-  /**
-   * 删除命名空间
-   * @param namespace 已有的命名空间实例
-   */
-  removeNamespace(namespace: Namespace): void;
-
-  removeNamespace(options: string | Namespace) {
-    let namespace: Namespace;
-    if (typeof options === 'string') {
-      namespace = (this.namespaces as Namespace[]).find((item) => item.name === options);
-      if (!namespace) {
-        throw new Error('找不到命名空间 ' + options);
-      }
-    } else {
-      namespace = options;
-    }
-    return namespace.delete();
-  }
-
-  __removeNamespace(namespace: Namespace) {
-    const parentKey = namespace.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: namespace,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = namespace.__v_raw || namespace;
-      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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          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;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = triggerLauncher.__v_raw || triggerLauncher;
-      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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === 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])) {
-        // @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 {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
-  //================================================================================
-  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-  // 自动生成的代码已结束。下面可以手动编写。
-  //================================================================================
-
-  getActions() {
-    // 自定义连接器有分组的概念
-    if (this.connectorKind === 'app') {
-      return this.namespaces.map((namespace) => {
-        return {
-          title: namespace.title,
-          name: namespace.name,
-          expanded: true,
-          unselectable: true, // 自定义属性。用于标注当前选项是否可以被选择
-          children: namespace.logics,
-        };
-      });
-    }
-    return this.logics;
-  }
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  _addAuthLogic(authLogic: AuthLogic): AuthLogic;
 
-  getNamespaceExistingTitles(excludedList: Array<Namespace> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.namespaces as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
+  _addAuthLogic(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const index = this.authLogics.length;
+    return this._insertAuthLogicAt(options as any, index);
   }
 
-  getNamespaceUniqueTitle(name = '分组1') {
-    return utils.unique(name, this.getNamespaceExistingTitles(), undefined, false);
+  /**
+   * 添加鉴权逻辑
+   * @internal
+   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   */
+  addAuthLogic(name?: string): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @param authLogicOptions 鉴权逻辑参数
+   */
+  addAuthLogic(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+
+  /**
+   * 添加鉴权逻辑
+   * @param authLogic 已有的鉴权逻辑实例
+   */
+  addAuthLogic(authLogic: AuthLogic): AuthLogic;
+
+  addAuthLogic(options?: string | Partial<AuthLogic> | AuthLogic) {
+    const node = this._addAuthLogic(options as any);
+    const index = this.authLogics.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'authLogics',
+    });
+    return node;
   }
 
-  // ================  为解决循环引用而将之前的自动生成代码移动到这里  START =================
   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);
   }
@@ -2029,18 +909,39 @@ export class Connector extends Module {
   ) {
     const authLogicForCallInterfaceOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'authLogicsForCallInterface' };
+    const AuthLogicForCallInterface = getConceptConstructor('AuthLogicForCallInterface');
     let authLogicForCallInterface: AuthLogicForCallInterface;
     if (!options) {
-      throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
+        {
+          ...authLogicForCallInterfaceOptions,
+          name: this.getAuthLogicForCallInterfaceUniqueName(),
+        },
+        this,
+        'authLogicsForCallInterface',
+      );
     } else if (typeof options === 'string') {
-      throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
-      // FIXME : dont change
-    } else if (options.concept === 'AuthLogicForCallInterface') {
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
+        {
+          ...authLogicForCallInterfaceOptions,
+          name: options,
+        },
+        this,
+        'authLogicsForCallInterface',
+      );
+    } else if (asserts.isAuthLogicForCallInterface(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      authLogicForCallInterface = options as any;
+      authLogicForCallInterface = options;
       Object.assign(authLogicForCallInterface, relationOptions);
     } else {
-      throw Error('请先调用from方法创建AuthLogicForCallInterface实例');
+      authLogicForCallInterface = AuthLogicForCallInterface.from(
+        {
+          ...authLogicForCallInterfaceOptions,
+          ...options,
+        },
+        this,
+        'authLogicsForCallInterface',
+      );
     }
     this.authLogicsForCallInterface.splice(index, 0, authLogicForCallInterface);
     return authLogicForCallInterface;
@@ -2144,202 +1045,192 @@ export class Connector extends Module {
   }
 
   /**
-   * 删除调用接口的鉴权逻辑
-   * @param name 调用接口的鉴权逻辑名称
+   * 删除输入参数
+   * @param name 输入参数名称
    */
-  removeAuthLogicForCallInterface(name: string): void;
+  removeParam(name: string): void;
 
   /**
-   * 删除调用接口的鉴权逻辑
-   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
+   * 删除输入参数
+   * @param param 已有的输入参数实例
    */
-  removeAuthLogicForCallInterface(authLogicForCallInterface: AuthLogicForCallInterface): void;
+  removeParam(param: Param): void;
 
-  removeAuthLogicForCallInterface(options: string | AuthLogicForCallInterface) {
-    let authLogicForCallInterface: AuthLogicForCallInterface;
+  removeParam(options: string | Param) {
+    let param: Param;
     if (typeof options === 'string') {
-      authLogicForCallInterface = (this.authLogicsForCallInterface as AuthLogicForCallInterface[]).find(
-        (item) => item.name === options,
-      );
-      if (!authLogicForCallInterface) {
-        throw new Error('找不到调用接口的鉴权逻辑 ' + options);
+      param = (this.properties as Param[]).find((item) => item.name === options);
+      if (!param) {
+        throw new Error('找不到输入参数 ' + options);
       }
     } else {
-      authLogicForCallInterface = options;
+      param = options;
     }
-    return authLogicForCallInterface.delete();
+    return param.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 连接器触发器名称
+   */
+  removeConnectorTrigger(name: string): void;
 
   /**
-   * 插入鉴权逻辑
-   * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 删除连接器触发器
+   * @param connectorTrigger 已有的连接器触发器实例
    */
-  _insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
+  removeConnectorTrigger(connectorTrigger: ConnectorTrigger): void;
+
+  removeConnectorTrigger(options: string | ConnectorTrigger) {
+    let connectorTrigger: ConnectorTrigger;
+    if (typeof options === 'string') {
+      connectorTrigger = (this.triggers as ConnectorTrigger[]).find((item) => item.name === options);
+      if (!connectorTrigger) {
+        throw new Error('找不到连接器触发器 ' + options);
+      }
+    } else {
+      connectorTrigger = options;
+    }
+    return connectorTrigger.delete();
+  }
 
   /**
-   * 插入鉴权逻辑
-   * @internal
-   * @param authLogicOptions 鉴权逻辑参数
+   * 删除命名空间
+   * @param name 命名空间名称
    */
-  _insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+  removeNamespace(name: string): void;
 
   /**
-   * 插入鉴权逻辑
-   * @internal
-   * @param authLogic 已有的鉴权逻辑实例
+   * 删除命名空间
+   * @param namespace 已有的命名空间实例
    */
-  _insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+  removeNamespace(namespace: Namespace): void;
 
-  _insertAuthLogicInAuthLogicsAt(options: string | Partial<AuthLogic> | AuthLogic, index: number) {
-    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);
+  removeNamespace(options: string | Namespace) {
+    let namespace: Namespace;
+    if (typeof options === 'string') {
+      namespace = (this.namespaces as Namespace[]).find((item) => item.name === options);
+      if (!namespace) {
+        throw new Error('找不到命名空间 ' + options);
+      }
     } else {
-      // authLogic = AuthLogic.from({
-      //     ...authLogicOptions,
-      //     ...options,
-      // }, this, 'authLogics');
-      throw Error('请先调用from方法');
+      namespace = options;
     }
-    this.authLogics.splice(index, 0, authLogic);
-    return authLogic;
+    return namespace.delete();
   }
 
   /**
-   * 插入鉴权逻辑
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
-   */
-  insertAuthLogicInAuthLogicsAt(name: string, index: number): AuthLogic;
-
-  /**
-   * 插入鉴权逻辑
-   * @param authLogicOptions 鉴权逻辑参数
+   * 删除鉴权逻辑
+   * @param name 鉴权逻辑名称
    */
-  insertAuthLogicInAuthLogicsAt(authLogicOptions: Partial<AuthLogic>, index: number): AuthLogic;
+  removeAuthLogic(name: string): void;
 
   /**
-   * 插入鉴权逻辑
+   * 删除鉴权逻辑
    * @param authLogic 已有的鉴权逻辑实例
    */
-  insertAuthLogicInAuthLogicsAt(authLogic: AuthLogic, index: number): AuthLogic;
+  removeAuthLogic(authLogic: AuthLogic): void;
 
-  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;
+  removeAuthLogic(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();
   }
 
   /**
-   * 添加鉴权逻辑
-   * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 删除调用接口的鉴权逻辑
+   * @param name 调用接口的鉴权逻辑名称
    */
-  _addAuthLogicInAuthLogics(name?: string): AuthLogic;
+  removeAuthLogicForCallInterface(name: string): void;
 
   /**
-   * 添加鉴权逻辑
-   * @internal
-   * @param authLogicOptions 鉴权逻辑参数
+   * 删除调用接口的鉴权逻辑
+   * @param authLogicForCallInterface 已有的调用接口的鉴权逻辑实例
    */
-  _addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
+  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();
+  }
 
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
   /**
-   * 添加鉴权逻辑
-   * @internal
-   * @param authLogic 已有的鉴权逻辑实例
+   * 祖先 Module
    */
-  _addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
-
-  _addAuthLogicInAuthLogics(options?: string | Partial<AuthLogic> | AuthLogic) {
-    const index = this.authLogics.length;
-    return this._insertAuthLogicInAuthLogicsAt(options as any, index);
+  get module() {
+    return this.getAncestor('Module') as Module;
   }
-
   /**
-   * 添加鉴权逻辑
-   * @internal
-   * @param name 鉴权逻辑名称，如果不填会自动生成一个唯一名称
+   * 祖先 View
    */
-  addAuthLogicInAuthLogics(name?: string): AuthLogic;
-
+  get view() {
+    return this.getAncestor('View') as View;
+  }
   /**
-   * 添加鉴权逻辑
-   * @param authLogicOptions 鉴权逻辑参数
+   * 祖先 Frontend
    */
-  addAuthLogicInAuthLogics(authLogicOptions: Partial<AuthLogic>): AuthLogic;
-
+  get frontend() {
+    return this.getAncestor('Frontend') as Frontend;
+  }
   /**
-   * 添加鉴权逻辑
-   * @param authLogic 已有的鉴权逻辑实例
+   * 祖先 ProcessElement
+   */
+  get processElement() {
+    return this.getAncestor('ProcessElement') as ProcessElement;
+  }
+  /**
+   * 祖先 Process
    */
-  addAuthLogicInAuthLogics(authLogic: AuthLogic): AuthLogic;
+  get process() {
+    return this.getAncestor('Process') as Process;
+  }
 
-  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;
+  getActions() {
+    // 自定义连接器有分组的概念
+    if (this.connectorKind === 'app') {
+      return this.namespaces.map((namespace) => {
+        return {
+          title: namespace.title,
+          name: namespace.name,
+          expanded: true,
+          unselectable: true, // 自定义属性。用于标注当前选项是否可以被选择
+          children: namespace.logics,
+        };
+      });
+    }
+    return this.logics;
   }
 
-  getAuthLogicExistingNames(excludedList: Array<AuthLogic> = []) {
+  getNamespaceExistingTitles(excludedList: Array<Namespace> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.authLogics as AuthLogic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.namespaces as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
   }
 
-  getAuthLogicUniqueName(name = 'authentication1') {
-    return utils.unique(name, this.getAuthLogicExistingNames(), undefined, true);
+  getNamespaceUniqueTitle(name = '分组1') {
+    return utils.unique(name, this.getNamespaceExistingTitles(), undefined, false);
   }
 
-  // ================  为解决循环引用而将之前的自动生成代码移动到这里  END =================
-
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓