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

package/src/concepts/TypeAnnotation__.ts

@@ -1,76 +1,89 @@
+import { v4 as uuidv4 } from 'uuid';
 import App from './App__';
 import Structure from './Structure__';
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import { genHash } from '../generator';
 import { firstUpperCase } from '../utils/string';
 
+//= ===============================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//= ===============================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property } from '../decorators';
+
+import * as utils from '../utils';
+import BaseNode from '../common/BaseNode';
+import classMap from '../common/classMap';
+import StructureProperty from './StructureProperty__';
+
 export enum PRIMITIVE_TYPE {
-    Boolean = 'Boolean',
-    Integer = 'Integer',
-    Long = 'Long',
-    Double = 'Double',
-    Decimal = 'Decimal',
-    String = 'String',
-    Text = 'Text',
-    Binary = 'Binary',
-    Date = 'Date',
-    Time = 'Time',
-    DateTime = 'DateTime',
-    Email = 'Email',
-    Union = 'Union',
-    Null = 'Null'
+  Boolean = 'Boolean',
+  Integer = 'Integer',
+  Long = 'Long',
+  Double = 'Double',
+  Decimal = 'Decimal',
+  String = 'String',
+  Text = 'Text',
+  Binary = 'Binary',
+  Date = 'Date',
+  Time = 'Time',
+  DateTime = 'DateTime',
+  Email = 'Email',
+  Union = 'Union',
+  Null = 'Null',
 }
 
 export const PRIMITIVE_TITLE: Record<string, string> = {
-    Boolean: '布尔值',
-    Integer: '整数',
-    Long: '整数',
-    Double: '小数',
-    Decimal: '小数',
-    String: '文本',
-    Text: '长文本',
-    Binary: '二进制流',
-    Date: '日期',
-    Time: '时间',
-    DateTime: '日期时间',
-    Email: '电子邮箱',
-    Union: '联合类型',
+  Boolean: '布尔值',
+  Integer: '整数',
+  Long: '整数',
+  Double: '小数',
+  Decimal: '小数',
+  String: '文本',
+  Text: '长文本',
+  Binary: '二进制流',
+  Date: '日期',
+  Time: '时间',
+  DateTime: '日期时间',
+  Email: '电子邮箱',
+  Union: '联合类型',
 };
 
 export const OLD_PRIMITIVE_TITLE: Record<string, string> = {
-    Boolean: '布尔值',
-    Integer: '整数',
-    Long: '长整数',
-    Double: '小数',
-    Decimal: '精准小数',
-    String: '字符串',
-    Text: '长文本',
-    Binary: '二进制流',
-    Date: '日期',
-    Time: '时间',
-    DateTime: '日期时间',
-    Email: '电子邮箱',
-    Union: '联合类型',
+  Boolean: '布尔值',
+  Integer: '整数',
+  Long: '长整数',
+  Double: '小数',
+  Decimal: '精准小数',
+  String: '字符串',
+  Text: '长文本',
+  Binary: '二进制流',
+  Date: '日期',
+  Time: '时间',
+  DateTime: '日期时间',
+  Email: '电子邮箱',
+  Union: '联合类型',
 };
 
 export const PRIMITIVE_DESC: Record<string, string> = {
-    Integer: '可表示最大长度约 10 个数字的正负整数（将被删除）',
-    Double: '小数，有效数字约 16 个左右（将被删除）',
-    Text: '底层与String相同，可存储更长的内容（将被删除）',
-    Binary: '用于二进制流的存储',
-    Email: '表示一个邮箱，底层与String相同（将被删除）',
-    Boolean: '包含真（true）、假（false）两个值',
-    Long: '可表示最大长度约 19 个数字的正负整数',
-    Decimal: '可表示 31 个有效数字以内的小数',
-    String: '表示汉语、英语、数字等文本内容',
-    Date: '通常用于仅日期处理和数据存储',
-    Time: '通常用于仅时间处理和数据存储',
-    DateTime: '通常用于日期和时间的处理和数据存储',
+  Integer: '可表示最大长度约 10 个数字的正负整数（将被删除）',
+  Double: '小数，有效数字约 16 个左右（将被删除）',
+  Text: '底层与String相同，可存储更长的内容（将被删除）',
+  Binary: '用于二进制流的存储',
+  Email: '表示一个邮箱，底层与String相同（将被删除）',
+  Boolean: '包含真（true）、假（false）两个值',
+  Long: '可表示最大长度约 19 个数字的正负整数',
+  Decimal: '可表示 31 个有效数字以内的小数',
+  String: '表示汉语、英语、数字等文本内容',
+  Date: '通常用于仅日期处理和数据存储',
+  Time: '通常用于仅时间处理和数据存储',
+  DateTime: '通常用于日期和时间的处理和数据存储',
 };
 
 export const GENERIC_DESC: Record<string, string> = {
-    List: 'T类型的数据构成的列表',
-    Map: '从K类型到V类型的映射',
+  List: 'T类型的数据构成的列表',
+  Map: '从K类型到V类型的映射',
 };
 
 /**
@@ -79,1036 +92,1061 @@ export const GENERIC_DESC: Record<string, string> = {
  * @returns
  */
 export function isUnion(typeAnnotation: TypeAnnotation): boolean {
-    return typeAnnotation
-        && typeAnnotation.typeKind === 'union'
-        && typeAnnotation.typeNamespace === 'nasl.core'
-        && typeAnnotation.typeName === 'Union';
+  return typeAnnotation && typeAnnotation.typeKind === 'union' && typeAnnotation.typeNamespace === 'nasl.core' && typeAnnotation.typeName === 'Union';
 }
 
-//================================================================================
-// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
-import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property } from '../decorators';
-
-import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
-import BaseNode from '../common/BaseNode';
-import classMap from '../common/classMap';
-import StructureProperty from './StructureProperty__';
-
 /**
  * 类型标注
  */
 @concept('类型标注')
 export class TypeAnnotation extends BaseNode {
-    /**
-     * 产品概念
-     */
-    @property()
-    concept: 'TypeAnnotation' = 'TypeAnnotation';
-
-    /**
-     * 类型种类
-     */
-    @property()
-    typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure' = undefined;
-
-    /**
-     * 类型命名空间
-     */
-    @property()
-    typeNamespace?: string = undefined;
-
-    /**
-     * 类型名称
-     */
-    @property()
-    typeName: string = undefined;
-
-    /**
-     * 类型参数
-     */
-    @property('TypeAnnotation')
-    typeArguments?: Array<TypeAnnotation> = null;
-
-    /**
-     * 返回类型
-     */
-    @property('TypeAnnotation')
-    returnType?: Array<TypeAnnotation> = null;
-
-    /**
-     * 是否是推断出来的
-     */
-    @property()
-    inferred?: boolean = undefined;
-
-    /**
-     * 匿名数据结构属性
-     */
-    @property('StructureProperty')
-    properties?: Array<StructureProperty> = null;
-
-    /**
-     * 规则对象
-     */
-    @property()
-    ruleMap: Object = undefined;
-
-
-
-    /**
-     * @param source 需要合并的部分参数
-     */
-    constructor(source?: Partial<TypeAnnotation>) {
-        source = Object.assign({}, TypeAnnotation.getDefaultOptions(), source);
-        super(source);
-        super.subConstructor(source);
+  /**
+   * 产品概念
+   */
+  @property()
+  concept: 'TypeAnnotation' = 'TypeAnnotation';
+
+  /**
+   * 类型种类
+   */
+  @property()
+  typeKind: 'primitive' | 'reference' | 'generic' | 'typeParam' | 'function' | 'union' | 'anonymousStructure' = undefined;
+
+  /**
+   * 类型命名空间
+   */
+  @property()
+  typeNamespace?: string = undefined;
+
+  /**
+   * 类型名称
+   */
+  @property()
+  typeName: string = undefined;
+
+  /**
+   * 类型参数
+   */
+  @property('TypeAnnotation')
+  typeArguments?: Array<TypeAnnotation> = null;
+
+  /**
+   * 返回类型
+   */
+  @property('TypeAnnotation')
+  returnType?: Array<TypeAnnotation> = null;
+
+  /**
+   * 是否是推断出来的
+   */
+  @property()
+  inferred?: boolean = undefined;
+
+  /**
+   * 匿名数据结构属性
+   */
+  @property('StructureProperty')
+  properties?: Array<StructureProperty> = null;
+
+  /**
+   * 规则对象
+   */
+  @property()
+  ruleMap: Object = undefined;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<TypeAnnotation>) {
+    // @ts-ignore
+    source = { ...TypeAnnotation.getDefaultOptions(), ...source };
+    super(source);
+    super.subConstructor(source);
+  }
+
+  getClassName() {
+    return 'TypeAnnotation';
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): TypeAnnotation {
+    return super.from(source, parentNode, parentKey) as TypeAnnotation;
+  }
+
+  /**
+   * 从父级删除该节点
+   * @internal
+   */
+  _delete() {
+    let params: Params = null;
+    if (this.parentNode) {
+      params = (this.parentNode as any)?.__removeTypeAnnotation?.(this);
     }
-    getClassName() {
-        return 'TypeAnnotation';
+    return params;
+  }
+
+  /**
+   * 设置规则对象
+   */
+  setRuleMap(ruleMap: Object) {
+    const object = {
+      ruleMap,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 插入类型标注
+   * @internal
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  _insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+  /**
+   * 插入类型标注
+   * @internal
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  _insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+  _insertTypeAnnotationInTypeArgumentsAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+    const typeAnnotationOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
+    let typeAnnotation: TypeAnnotation;
+    if (options instanceof TypeAnnotation) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      typeAnnotation = options;
+      Object.assign(typeAnnotation, relationOptions);
+    } else {
+      typeAnnotation = TypeAnnotation.from(
+        {
+          ...typeAnnotationOptions,
+          ...options,
+        },
+        this,
+        'typeArguments'
+      );
     }
-
-    static from(source: any, parentNode?: any, parentKey?: string): TypeAnnotation {
-        return super.from(source, parentNode, parentKey) as TypeAnnotation;
+    this.typeArguments.splice(index, 0, typeAnnotation);
+    return typeAnnotation;
+  }
+
+  /**
+   * 插入类型标注
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+  /**
+   * 插入类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+  insertTypeAnnotationInTypeArgumentsAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+    const node = this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'typeArguments',
+    });
+    return node;
+  }
+
+  /**
+   * 添加类型标注
+   * @internal
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  _addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+  /**
+   * 添加类型标注
+   * @internal
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  _addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+  _addTypeAnnotationInTypeArguments(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+    const index = this.typeArguments.length;
+    return this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
+  }
+
+  /**
+   * 添加类型标注
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+  /**
+   * 添加类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+  addTypeAnnotationInTypeArguments(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+    const node = this._addTypeAnnotationInTypeArguments(options as any);
+    const index = this.typeArguments.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'typeArguments',
+    });
+    return node;
+  }
+
+  /**
+   * 插入类型标注
+   * @internal
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  _insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+  /**
+   * 插入类型标注
+   * @internal
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  _insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+  _insertTypeAnnotationInReturnTypeAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+    const typeAnnotationOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'returnType' };
+    let typeAnnotation: TypeAnnotation;
+    if (options instanceof TypeAnnotation) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      typeAnnotation = options;
+      Object.assign(typeAnnotation, relationOptions);
+    } else {
+      typeAnnotation = TypeAnnotation.from(
+        {
+          ...typeAnnotationOptions,
+          ...options,
+        },
+        this,
+        'returnType'
+      );
     }
-
-    /**
-     * 从父级删除该节点
-     * @internal
-     */
-    _delete() {
-        let params: Params = null;
-        if (this.parentNode) {
-            params = (this.parentNode as any)?.__removeTypeAnnotation?.(this);
-        }
-        return params;
+    this.returnType.splice(index, 0, typeAnnotation);
+    return typeAnnotation;
+  }
+
+  /**
+   * 插入类型标注
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
+
+  /**
+   * 插入类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
+
+  insertTypeAnnotationInReturnTypeAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
+    const node = this._insertTypeAnnotationInReturnTypeAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'returnType',
+    });
+    return node;
+  }
+
+  /**
+   * 添加类型标注
+   * @internal
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  _addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+  /**
+   * 添加类型标注
+   * @internal
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  _addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+  _addTypeAnnotationInReturnType(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+    const index = this.returnType.length;
+    return this._insertTypeAnnotationInReturnTypeAt(options as any, index);
+  }
+
+  /**
+   * 添加类型标注
+   * @param typeAnnotationOptions 类型标注参数
+   */
+  addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
+
+  /**
+   * 添加类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
+
+  addTypeAnnotationInReturnType(options?: Partial<TypeAnnotation> | TypeAnnotation) {
+    const node = this._addTypeAnnotationInReturnType(options as any);
+    const index = this.returnType.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'returnType',
+    });
+    return node;
+  }
+
+  /**
+   * 插入数据结构属性
+   * @internal
+   * @param structurePropertyOptions 数据结构属性参数
+   */
+  _insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+
+  /**
+   * 插入数据结构属性
+   * @internal
+   * @param structureProperty 已有的数据结构属性实例
+   */
+  _insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
+
+  _insertStructurePropertyAt(options: Partial<StructureProperty> | StructureProperty, index: number) {
+    const structurePropertyOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'properties' };
+    let structureProperty: StructureProperty;
+    if (options instanceof StructureProperty) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      structureProperty = options;
+      Object.assign(structureProperty, relationOptions);
+    } else {
+      structureProperty = StructureProperty.from(
+        {
+          ...structurePropertyOptions,
+          ...options,
+        },
+        this,
+        'properties'
+      );
     }
-    /**
-     * 设置规则对象
-     */
-    setRuleMap(ruleMap: Object) {
-        const object = {
-            ruleMap,
-        };
-        this.update({
-            ...object,
-        });
+    this.properties.splice(index, 0, structureProperty);
+    return structureProperty;
+  }
+
+  /**
+   * 插入数据结构属性
+   * @param structurePropertyOptions 数据结构属性参数
+   */
+  insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+
+  /**
+   * 插入数据结构属性
+   * @param structureProperty 已有的数据结构属性实例
+   */
+  insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
+
+  insertStructurePropertyAt(options: Partial<StructureProperty> | StructureProperty, index: number) {
+    const node = this._insertStructurePropertyAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'properties',
+    });
+    return node;
+  }
+
+  /**
+   * 添加数据结构属性
+   * @internal
+   * @param structurePropertyOptions 数据结构属性参数
+   */
+  _addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
+
+  /**
+   * 添加数据结构属性
+   * @internal
+   * @param structureProperty 已有的数据结构属性实例
+   */
+  _addStructureProperty(structureProperty: StructureProperty): StructureProperty;
+
+  _addStructureProperty(options?: Partial<StructureProperty> | StructureProperty) {
+    const index = this.properties.length;
+    return this._insertStructurePropertyAt(options as any, index);
+  }
+
+  /**
+   * 添加数据结构属性
+   * @param structurePropertyOptions 数据结构属性参数
+   */
+  addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
+
+  /**
+   * 添加数据结构属性
+   * @param structureProperty 已有的数据结构属性实例
+   */
+  addStructureProperty(structureProperty: StructureProperty): StructureProperty;
+
+  addStructureProperty(options?: Partial<StructureProperty> | StructureProperty) {
+    const node = this._addStructureProperty(options as any);
+    const index = this.properties.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'properties',
+    });
+    return node;
+  }
+
+  /**
+   * 删除类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
+
+  removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
+    const typeAnnotation: TypeAnnotation = options;
+    return typeAnnotation.delete();
+  }
+
+  /**
+   * 删除类型标注
+   * @param typeAnnotation 已有的类型标注实例
+   */
+  removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
+
+  removeTypeAnnotationInReturnType(options: TypeAnnotation) {
+    const typeAnnotation: TypeAnnotation = options;
+    return typeAnnotation.delete();
+  }
+
+  __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
+    const { parentKey } = typeAnnotation;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: typeAnnotation,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(typeAnnotation);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === typeAnnotation) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
     }
-
-
-
-
-
-    /**
-    * 插入类型标注
-    * @internal
-    * @param typeAnnotationOptions 类型标注参数
-    */
-    _insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
-
-    /**
-    * 插入类型标注
-    * @internal
-    * @param typeAnnotation 已有的类型标注实例
-    */
-    _insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
-
-    _insertTypeAnnotationInTypeArgumentsAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-        const typeAnnotationOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
-        let typeAnnotation: TypeAnnotation;
-        if (options instanceof TypeAnnotation) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            typeAnnotation = options;
-            Object.assign(typeAnnotation, relationOptions);
-        } else {
-            typeAnnotation = TypeAnnotation.from({
-                ...typeAnnotationOptions,
-                ...options,
-            }, this, 'typeArguments');
+    return params;
+  }
+
+  /**
+   * 删除数据结构属性
+   * @param structureProperty 已有的数据结构属性实例
+   */
+  removeStructureProperty(structureProperty: StructureProperty): void;
+
+  removeStructureProperty(options: StructureProperty) {
+    const structureProperty: StructureProperty = options;
+    return structureProperty.delete();
+  }
+
+  __removeStructureProperty(structureProperty: StructureProperty) {
+    const { parentKey } = structureProperty;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: structureProperty,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(structureProperty);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === structureProperty) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  //= ===============================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //= ===============================================================================
+
+  toUI(state?: TranslatorState): string {
+    return this.headTitle;
+  }
+
+  traverse(
+    callback: (arg: TypeAnnotation) => void,
+    enter: (arg: TypeAnnotation) => void,
+    leave: (arg: TypeAnnotation) => void,
+    onJoin: (arg: TypeAnnotation, arg2: TypeAnnotation) => void
+  ) {
+    enter(this);
+    callback(this);
+    if (this.typeArguments && ['generic', 'union'].includes(this.typeKind)) {
+      const l = this.typeArguments.length;
+      this.typeArguments.forEach((arg, idx) => {
+        arg.traverse(callback, enter, leave, onJoin);
+        if (idx < l - 1) {
+          onJoin(this, arg);
         }
-        this.typeArguments.splice(index, 0, typeAnnotation);
-        return typeAnnotation;
+      });
     }
+    leave(this);
+  }
 
-
-
-    /**
-     * 插入类型标注
-     * @param typeAnnotationOptions 类型标注参数
-     */
-    insertTypeAnnotationInTypeArgumentsAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
-
-    /**
-     * 插入类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    insertTypeAnnotationInTypeArgumentsAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
-
-    insertTypeAnnotationInTypeArgumentsAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-        const node = this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'typeArguments',
-        });
-        return node;
+  get typeKey(): string {
+    if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+      return `${this.typeNamespace}.${this.typeName}`;
     }
-
-
-
-    /**
-     * 添加类型标注
-     * @internal
-     * @param typeAnnotationOptions 类型标注参数
-     */
-    _addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
-
-    /**
-     * 添加类型标注
-     * @internal
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    _addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
-
-    _addTypeAnnotationInTypeArguments(options?: Partial<TypeAnnotation> | TypeAnnotation) {
-        const index = this.typeArguments.length;
-        return this._insertTypeAnnotationInTypeArgumentsAt(options as any, index);
+    if (this.typeKind === 'generic') {
+      return `${this.typeNamespace}.${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeKey)}>`;
     }
-
-
-
-    /**
-     * 添加类型标注
-     * @param typeAnnotationOptions 类型标注参数
-     */
-    addTypeAnnotationInTypeArguments(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
-
-    /**
-     * 添加类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    addTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): TypeAnnotation;
-
-    addTypeAnnotationInTypeArguments(options?: Partial<TypeAnnotation> | TypeAnnotation) {
-        const node = this._addTypeAnnotationInTypeArguments(options as any);
-        const index = this.typeArguments.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'typeArguments',
-        });
-        return node;
+    if (this.typeKind === 'anonymousStructure') {
+      return `{ ${this.properties.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeKey : '未知'}`).join(', ')} }`;
     }
-
-
-
-    /**
-    * 插入类型标注
-    * @internal
-    * @param typeAnnotationOptions 类型标注参数
-    */
-    _insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
-
-    /**
-    * 插入类型标注
-    * @internal
-    * @param typeAnnotation 已有的类型标注实例
-    */
-    _insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
-
-    _insertTypeAnnotationInReturnTypeAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-        const typeAnnotationOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'returnType' };
-        let typeAnnotation: TypeAnnotation;
-        if (options instanceof TypeAnnotation) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            typeAnnotation = options;
-            Object.assign(typeAnnotation, relationOptions);
-        } else {
-            typeAnnotation = TypeAnnotation.from({
-                ...typeAnnotationOptions,
-                ...options,
-            }, this, 'returnType');
-        }
-        this.returnType.splice(index, 0, typeAnnotation);
-        return typeAnnotation;
+    if (this.typeKind === 'union') {
+      return `${this.typeArguments.map((arg) => arg.typeKey).join(' | ')}`;
     }
-
-
-
-    /**
-     * 插入类型标注
-     * @param typeAnnotationOptions 类型标注参数
-     */
-    insertTypeAnnotationInReturnTypeAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
-
-    /**
-     * 插入类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    insertTypeAnnotationInReturnTypeAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
-
-    insertTypeAnnotationInReturnTypeAt(options: Partial<TypeAnnotation> | TypeAnnotation, index: number) {
-        const node = this._insertTypeAnnotationInReturnTypeAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'returnType',
-        });
-        return node;
+    return this.typeName;
+  }
+
+  // 排过序的类型标识
+  get sortedTypeKey(): string {
+    if (this.typeKind === 'anonymousStructure') {
+      // 按匿名数据结构的key排序
+      return `{${[...this.properties]
+        .sort(({ name: name1 }, { name: name2 }) => (name1 > name2 ? 1 : -1))
+        .map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.sortedTypeKey : '未知'}`)
+        .join(', ')}}`;
     }
-
-
-
-    /**
-     * 添加类型标注
-     * @internal
-     * @param typeAnnotationOptions 类型标注参数
-     */
-    _addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
-
-    /**
-     * 添加类型标注
-     * @internal
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    _addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
-
-    _addTypeAnnotationInReturnType(options?: Partial<TypeAnnotation> | TypeAnnotation) {
-        const index = this.returnType.length;
-        return this._insertTypeAnnotationInReturnTypeAt(options as any, index);
+    if (this.typeKind === 'union') {
+      // 按返回的每个具体项排序
+      return `${this.typeArguments
+        .map((arg) => arg.sortedTypeKey)
+        .sort((name1, name2) => (name1 > name2 ? 1 : -1))
+        .join(' | ')}`;
     }
-
-
-
-    /**
-     * 添加类型标注
-     * @param typeAnnotationOptions 类型标注参数
-     */
-    addTypeAnnotationInReturnType(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
-
-    /**
-     * 添加类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    addTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): TypeAnnotation;
-
-    addTypeAnnotationInReturnType(options?: Partial<TypeAnnotation> | TypeAnnotation) {
-        const node = this._addTypeAnnotationInReturnType(options as any);
-        const index = this.returnType.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'returnType',
-        });
-        return node;
+    const typeArr = [];
+    if (this.typeNamespace) {
+      typeArr.push(this.typeNamespace);
     }
-
-
-
-
-
-
-    /**
-    * 插入数据结构属性
-    * @internal
-    * @param structurePropertyOptions 数据结构属性参数
-    */
-    _insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
-
-    /**
-    * 插入数据结构属性
-    * @internal
-    * @param structureProperty 已有的数据结构属性实例
-    */
-    _insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
-
-    _insertStructurePropertyAt(options: Partial<StructureProperty> | StructureProperty, index: number) {
-        const structurePropertyOptions: any = {};
-        const relationOptions = { parentNode: this, parentKey: 'properties' };
-        let structureProperty: StructureProperty;
-        if (options instanceof StructureProperty) {
-            options.ensureDelete(); // 同一实例不支持多处存在
-            structureProperty = options;
-            Object.assign(structureProperty, relationOptions);
-        } else {
-            structureProperty = StructureProperty.from({
-                ...structurePropertyOptions,
-                ...options,
-            }, this, 'properties');
+    if (this.typeName) {
+      typeArr.push(this.typeName);
+    }
+    const typeKey = typeArr.join('.');
+    if (this.typeKind === 'generic') {
+      let code = typeKey;
+      code += '<';
+      if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+        // 必须按typeArguments定义的顺序，否则实参位置不对
+        code += `${(this.typeArguments || []).map((arg) => arg.sortedTypeKey).join(', ')}`;
+      }
+      code += '>';
+      return code;
+    }
+    return typeKey;
+  }
+
+  /**
+   * 用于展示的 type 标题
+   */
+  get headTitle(): string {
+    if (this.typeKind === 'primitive') {
+      if (this.typeName === 'Long') {
+        return `Integer ${PRIMITIVE_TITLE[this.typeName] || ''}`;
+      }
+      return `${this.typeName} ${PRIMITIVE_TITLE[this.typeName] || ''}`;
+    }
+    if (this.typeKind === 'reference') {
+      const typeNamespace = this?.typeNamespace;
+      let typeTitle = this.typeName;
+      if (typeNamespace && this.rootNode) {
+        const entity = (this.rootNode as any).findNodeByCompleteName?.([typeNamespace, this?.typeName].join('.'));
+        if (entity?.concept === 'Entity') {
+          const dataSourceName = entity.dataSource?.name;
+          if (dataSourceName) {
+            typeTitle += `（${dataSourceName}）`;
+          }
         }
-        this.properties.splice(index, 0, structureProperty);
-        return structureProperty;
+      }
+      return typeTitle;
     }
-
-
-
-    /**
-     * 插入数据结构属性
-     * @param structurePropertyOptions 数据结构属性参数
-     */
-    insertStructurePropertyAt(structurePropertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
-
-    /**
-     * 插入数据结构属性
-     * @param structureProperty 已有的数据结构属性实例
-     */
-    insertStructurePropertyAt(structureProperty: StructureProperty, index: number): StructureProperty;
-
-    insertStructurePropertyAt(options: Partial<StructureProperty> | StructureProperty, index: number) {
-        const node = this._insertStructurePropertyAt(options as any, index);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'properties',
-        });
-        return node;
+    if (this.typeKind === 'generic') {
+      if (this.typeArguments && this.typeArguments.length)
+        return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || arg.name || 'T').join(', ')}>`;
+      return this.typeName;
     }
-
-
-
-    /**
-     * 添加数据结构属性
-     * @internal
-     * @param structurePropertyOptions 数据结构属性参数
-     */
-    _addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
-
-    /**
-     * 添加数据结构属性
-     * @internal
-     * @param structureProperty 已有的数据结构属性实例
-     */
-    _addStructureProperty(structureProperty: StructureProperty): StructureProperty;
-
-    _addStructureProperty(options?: Partial<StructureProperty> | StructureProperty) {
-        const index = this.properties.length;
-        return this._insertStructurePropertyAt(options as any, index);
+    if (this.typeKind === 'anonymousStructure') {
+      return `{ ${this.properties?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation.headTitle}`).join(', ')} }`;
     }
-
-
-
-    /**
-     * 添加数据结构属性
-     * @param structurePropertyOptions 数据结构属性参数
-     */
-    addStructureProperty(structurePropertyOptions: Partial<StructureProperty>): StructureProperty;
-
-    /**
-     * 添加数据结构属性
-     * @param structureProperty 已有的数据结构属性实例
-     */
-    addStructureProperty(structureProperty: StructureProperty): StructureProperty;
-
-    addStructureProperty(options?: Partial<StructureProperty> | StructureProperty) {
-        const node = this._addStructureProperty(options as any);
-        const index = this.properties.indexOf(node);
-        node.create({
-            index,
-            parentNode: this,
-            parentKey: 'properties',
-        });
-        return node;
+    if (this.typeKind === 'union') {
+      return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
     }
-
-
-
-
-    /**
-     * 删除类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    removeTypeAnnotationInTypeArguments(typeAnnotation: TypeAnnotation): void;
-
-    removeTypeAnnotationInTypeArguments(options: TypeAnnotation) {
-        const typeAnnotation: TypeAnnotation = options;
-        return typeAnnotation.delete();
+    return this.typeName;
+  }
+
+  /**
+   * 用于展示的 type 标题
+   */
+  get typeTitle(): string {
+    if (this.typeKind === 'primitive') {
+      if (this.typeName === 'Long') {
+        return `Integer ${PRIMITIVE_TITLE[this.typeName] || ''}`;
+      }
+      return `${this.typeName} ${PRIMITIVE_TITLE[this.typeName] || ''}`;
     }
-
-
-
-    /**
-     * 删除类型标注
-     * @param typeAnnotation 已有的类型标注实例
-     */
-    removeTypeAnnotationInReturnType(typeAnnotation: TypeAnnotation): void;
-
-    removeTypeAnnotationInReturnType(options: TypeAnnotation) {
-        const typeAnnotation: TypeAnnotation = options;
-        return typeAnnotation.delete();
+    if (this.typeKind === 'reference') {
+      return this.typeName;
     }
-
-    __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-        const parentKey = typeAnnotation.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: typeAnnotation,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(typeAnnotation);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === typeAnnotation) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
+    if (this.typeKind === 'generic') {
+      return `${this.typeName}<${!this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
     }
-
-    /**
-     * 删除数据结构属性
-     * @param structureProperty 已有的数据结构属性实例
-     */
-    removeStructureProperty(structureProperty: StructureProperty): void;
-
-    removeStructureProperty(options: StructureProperty) {
-        const structureProperty: StructureProperty = options;
-        return structureProperty.delete();
+    if (this.typeKind === 'anonymousStructure') {
+      return `{ ${this.properties?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`).join(', ')} }`;
     }
-
-    __removeStructureProperty(structureProperty: StructureProperty) {
-        const parentKey = structureProperty.parentKey;
-        const params: Params = {
-            parentNode: this,
-            parentKey,
-            index: -1,
-            object: null,
-            oldObject: structureProperty,
-        };
-        if (parentKey) {
-            params.parentKey = parentKey;
-            if (Array.isArray((this as any)[parentKey])) {
-                const index = (this as any)[parentKey].indexOf(structureProperty);
-                ~index && (this as any)[parentKey].splice(index, 1);
-                params.index = index;
-            } else if ((this as any)[parentKey] === structureProperty) {
-                params.index = 0;
-                (this as any)[parentKey] = undefined;
-            }
-        }
-        return params;
+    if (this.typeKind === 'union') {
+      return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
     }
-
-    //================================================================================
-    // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
-    // 自动生成的代码已结束。下面可以手动编写。
-    //================================================================================
-
-    toUI(state?: TranslatorState): string {
-        return this.headTitle;
+    return this.typeName;
+  }
+
+  /**
+   * 用于展示的 无中文的精简type标题
+   */
+  get typeInlineTitle(): string {
+    if (this.typeKind === 'primitive') {
+      if (this.typeName === 'Long') {
+        return 'Integer';
+      }
+      return this.typeName;
     }
-
-    traverse(callback: (arg: TypeAnnotation) => void,
-        enter: (arg: TypeAnnotation) => void,
-        leave: (arg: TypeAnnotation) => void,
-        onJoin: (arg: TypeAnnotation, arg2: TypeAnnotation) => void) {
-        enter(this);
-        callback(this);
-        if (this.typeArguments && ['generic', 'union'].includes(this.typeKind)) {
-            const l = this.typeArguments.length;
-            this.typeArguments.forEach((arg, idx) => {
-                arg.traverse(callback, enter, leave, onJoin);
-                if (idx < l - 1) {
-                    onJoin(this, arg);
-                }
-            });
-        }
-        leave(this);
+    if (this.typeKind === 'reference') {
+      return this.typeName;
     }
-
-    get typeKey(): string {
-        if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
-            return `${this.typeNamespace}.${this.typeName}`;
-        } else if (this.typeKind === 'generic') {
-            return `${this.typeNamespace}.${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeKey)}>`;
-        } else if (this.typeKind === 'anonymousStructure') {
-            return `{ ${this.properties.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.typeKey : '未知'}`)).join(', ')} }`;
-        } else if (this.typeKind === 'union') {
-            return `${this.typeArguments.map((arg) => arg.typeKey).join(' | ')}`;
-        } else {
-            return this.typeName;
-        }
+    if (this.typeKind === 'generic') {
+      return `${this.typeName}<${!this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeInlineTitle || arg.name || 'T').join(', ')
+        }>`;
     }
-
-    // 排过序的类型标识
-    get sortedTypeKey(): string {
-        if (this.typeKind === 'anonymousStructure') {
-            // 按匿名数据结构的key排序
-            return `{${[...this.properties].sort(({ name: name1 }, { name: name2 }) => name1 > name2 ? 1 : -1).map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.sortedTypeKey : '未知'}`)).join(', ')}}`;
-        } else if (this.typeKind === 'union') {
-            // 按返回的每个具体项排序
-            return `${this.typeArguments.map((arg) => arg.sortedTypeKey).sort((name1, name2) => name1 > name2 ? 1 : -1).join(' | ')}`;
-        }
-        const typeArr = [];
-        if (this.typeNamespace) {
-            typeArr.push(this.typeNamespace);
-        }
-        if (this.typeName) {
-            typeArr.push(this.typeName);
-        }
-        const typeKey = typeArr.join('.');
-        if (this.typeKind === 'generic') {
-            let code = typeKey;
-            code += '<';
-            if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
-                // 必须按typeArguments定义的顺序，否则实参位置不对
-                code += `${(this.typeArguments || []).map((arg) => arg.sortedTypeKey).join(', ')}`;
-            }
-            code += '>';
-            return code;
-        }
-        return typeKey;
+    if (this.typeKind === 'anonymousStructure') {
+      return `{ ${this.properties
+        ?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeInlineTitle : '未知'}`)
+        .join(', ')} }`;
     }
-
-    /**
-     * 用于展示的 type 标题
-     */
-    get headTitle(): string {
-        if (this.typeKind === 'primitive') {
-            if (this.typeName === 'Long') {
-                return `Integer ${PRIMITIVE_TITLE[this.typeName] || ''}`;
-            }
-            return `${this.typeName} ${PRIMITIVE_TITLE[this.typeName] || ''}`;
-        } else if (this.typeKind === 'reference') {
-            const typeNamespace = this?.typeNamespace;
-            let typeTitle = this.typeName;
-            if (typeNamespace && this.rootNode) {
-                const entity = (this.rootNode as any).findNodeByCompleteName?.([typeNamespace, this?.typeName].join('.'));
-                if (entity?.concept === 'Entity') {
-                    const dataSourceName = entity.dataSource?.name;
-                    if (dataSourceName) {
-                        typeTitle += `（${dataSourceName}）`;
-                    }
-                }
-            }
-            return typeTitle;
-        } else if (this.typeKind === 'generic') {
-            if (this.typeArguments && this.typeArguments.length)
-                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.headTitle || arg.name || 'T').join(', ')}>`;
-            else
-                return this.typeName;
-        } else if (this.typeKind === 'anonymousStructure') {
-            return `{ ${this.properties?.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation.headTitle}`)).join(', ')} }`;
-        } else if (this.typeKind === 'union') {
-            return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
-        } else {
-            return this.typeName;
-        }
+    if (this.typeKind === 'union') {
+      return `${this.typeArguments.map((arg) => arg.typeInlineTitle || arg.name).join(' 或 ')}`;
     }
-
-    /**
-     * 用于展示的 type 标题
-     */
-    get typeTitle(): string {
-        if (this.typeKind === 'primitive') {
-            if (this.typeName === 'Long') {
-                return `Integer ${PRIMITIVE_TITLE[this.typeName] || ''}`;
-            }
-            return `${this.typeName} ${PRIMITIVE_TITLE[this.typeName] || ''}`;
-        } else if (this.typeKind === 'reference') {
-            return this.typeName;
-        } else if (this.typeKind === 'generic') {
-            return `${this.typeName}<${!this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeTitle || arg.name || 'T').join(', ')}>`;
-        } else if (this.typeKind === 'anonymousStructure') {
-            return `{ ${this.properties?.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`)).join(', ')} }`;
-        } else if (this.typeKind === 'union') {
-            return `${this.typeArguments.map((arg) => arg.typeTitle || arg.name).join(' 或 ')}`;
-        } else {
-            return this.typeName;
-        }
+    return this.typeName;
+  }
+
+  /**
+   * 用于展示的 纯中文的type 标题
+   */
+  get typeChineseTitle(): string {
+    if (this.typeKind === 'primitive') {
+      return `${PRIMITIVE_TITLE[this.typeName] || ''}`;
     }
-
-    /**
-     * 用于展示的 无中文的精简type标题
-     */
-    get typeInlineTitle(): string {
-        if (this.typeKind === 'primitive') {
-            if (this.typeName === 'Long') {
-                return 'Integer';
-            }
-            return this.typeName;
-        } else if (this.typeKind === 'reference') {
-            return this.typeName;
-        } else if (this.typeKind === 'generic') {
-            return `${this.typeName}<${!this.typeArguments.length ? 'T' : this.typeArguments.map((arg) => arg.typeInlineTitle || arg.name || 'T').join(', ')}>`;
-        } else if (this.typeKind === 'anonymousStructure') {
-            return `{ ${this.properties?.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.typeInlineTitle : '未知'}`)).join(', ')} }`;
-        } else if (this.typeKind === 'union') {
-            return `${this.typeArguments.map((arg) => arg.typeInlineTitle || arg.name).join(' 或 ')}`;
+    if (this.typeKind === 'reference') {
+      return this.typeName;
+    }
+    if (this.typeKind === 'generic') {
+      return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeChineseTitle || arg.name || 'T').join(', ')}>`;
+    }
+    if (this.typeKind === 'anonymousStructure') {
+      return `{ ${this.properties
+        ?.map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.typeChineseTitle : '未知'}`)
+        .join(', ')} }`;
+    }
+    if (this.typeKind === 'union') {
+      return `${this.typeArguments.map((arg) => arg.typeChineseTitle || arg.name).join(' 或 ')}`;
+    }
+    return this.typeName;
+  }
+
+  get typeTitleList() {
+    const typeTitleList: any[] = [];
+    if (this.typeKind === 'anonymousStructure') {
+      typeTitleList.push({ key: '{' });
+      const length = this.properties?.length;
+      this.properties?.forEach(({ name, typeAnnotation }, index) => {
+        if (index === length - 1) {
+          typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}` });
         } else {
-            return this.typeName;
+          typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`, dot: ',' });
         }
-    }
-
-    /**
-     * 用于展示的 纯中文的type 标题
-     */
-    get typeChineseTitle(): string {
-        if (this.typeKind === 'primitive') {
-            return `${PRIMITIVE_TITLE[this.typeName] || ''}`;
-        } else if (this.typeKind === 'reference') {
-            return this.typeName;
-        } else if (this.typeKind === 'generic') {
-            return `${this.typeName}<${this.typeArguments.map((arg) => arg.typeChineseTitle || arg.name || 'T').join(', ')}>`;
-        } else if (this.typeKind === 'anonymousStructure') {
-            return `{ ${this.properties?.map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.typeChineseTitle : '未知'}`)).join(', ')} }`;
-        } else if (this.typeKind === 'union') {
-            return `${this.typeArguments.map((arg) => arg.typeChineseTitle || arg.name).join(' 或 ')}`;
+      });
+      typeTitleList.push({ key: '}' });
+    } else if (this.typeName === 'List' && this.typeArguments?.length) {
+      if (this.typeArguments.every((item) => item.typeKind !== 'anonymousStructure')) {
+        typeTitleList.push({ key: this.typeTitle });
+      } else {
+        const propsTypeList = [].concat(...this.typeArguments.map((arg) => arg.typeTitleList));
+        if (propsTypeList[0]?.key === '{') {
+          propsTypeList[0].key = 'List<{';
         } else {
-            return this.typeName;
+          typeTitleList.push({ key: 'List<' });
         }
-    }
-
-    get typeTitleList() {
-        const typeTitleList: any[] = [];
-        if (this.typeKind === 'anonymousStructure') {
-            typeTitleList.push({ key: '{' });
-            const length = this.properties?.length;
-            this.properties?.forEach(({ name, typeAnnotation }, index) => {
-                if (index === length - 1) {
-                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}` });
-                } else {
-                    typeTitleList.push({ key: name, value: `${typeAnnotation ? typeAnnotation.typeTitle : '未知'}`, dot: ',' });
-                }
-            });
-            typeTitleList.push({ key: '}' });
-        } else if (this.typeName === 'List' && this.typeArguments?.length) {
-            if (this.typeArguments.every((item) => item.typeKind !== 'anonymousStructure')) {
-                typeTitleList.push({ key: this.typeTitle });
-            } else {
-                const propsTypeList = [].concat(...this.typeArguments.map((arg) => arg.typeTitleList));
-                if (propsTypeList[0]?.key === '{') {
-                    propsTypeList[0].key = 'List<{';
-                } else {
-                    typeTitleList.push({ key: 'List<' });
-                }
-                typeTitleList.push(...propsTypeList);
-                if (propsTypeList[propsTypeList.length - 1]?.key === '}') {
-                    propsTypeList[propsTypeList.length - 1].key = '}>';
-                } else {
-                    typeTitleList.push({ key: '>' });
-                }
-            }
+        typeTitleList.push(...propsTypeList);
+        if (propsTypeList[propsTypeList.length - 1]?.key === '}') {
+          propsTypeList[propsTypeList.length - 1].key = '}>';
         } else {
-            typeTitleList.push({ key: this.typeTitle });
+          typeTitleList.push({ key: '>' });
         }
-        return typeTitleList;
+      }
+    } else {
+      typeTitleList.push({ key: this.typeTitle });
     }
+    return typeTitleList;
+  }
 
-    static createPrimitive(typeName: string, source?: Partial<TypeAnnotation>) {
-        if ((PRIMITIVE_TYPE as any)[typeName]) {
-            return this.from(Object.assign({
-                typeKind: typeName === 'Union' ? 'union' : 'primitive',
-                typeName,
-                typeNamespace: 'nasl.core',
-            }, source));
-        }
+  static createPrimitive(typeName: string, source?: Partial<TypeAnnotation>) {
+    if ((PRIMITIVE_TYPE as any)[typeName]) {
+      return this.from({ typeKind: typeName === 'Union' ? 'union' : 'primitive', typeName, typeNamespace: 'nasl.core', ...source });
     }
-
-    static createReference(typeName: string, source?: Partial<TypeAnnotation>) {
-        return this.from(Object.assign({
-            typeKind: 'reference',
-            typeName,
-            typeNamespace: 'nasl.core',
-        }, source));
+  }
+
+  static createReference(typeName: string, source?: Partial<TypeAnnotation>) {
+    return this.from({ typeKind: 'reference', typeName, typeNamespace: 'nasl.core', ...source });
+  }
+
+  static createGeneric(typeName: string, source?: Partial<TypeAnnotation>) {
+    return this.from({ typeKind: 'generic', typeName, typeNamespace: 'nasl.collection', ...source });
+  }
+
+  static createTypeParam(typeName: string, source?: Partial<TypeAnnotation>) {
+    return this.from({ typeKind: 'typeParam', typeName, ...source });
+  }
+
+  static createTypeAnonymousStructure(properties: Array<StructureProperty>, source?: Partial<TypeAnnotation>) {
+    return this.from({ typeKind: 'anonymousStructure', properties, ...source });
+  }
+
+  /**
+   * 设置类型属性名称
+   */
+  setTypeName(typeName: string) {
+    const object = {
+      typeName,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置类型属性名称
+   */
+  setTypeNamespace(typeNamespace: string) {
+    const object = {
+      typeNamespace,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  get tsCalleeNamespace() {
+    if (this.typeNamespace) {
+      let tsCalleeNamespace = this.typeNamespace;
+      tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
+      tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
+      return tsCalleeNamespace;
     }
-
-    static createGeneric(typeName: string, source?: Partial<TypeAnnotation>) {
-        return this.from(Object.assign({
-            typeKind: 'generic',
-            typeName,
-            typeNamespace: 'nasl.collection',
-        }, source));
+    return '';
+  }
+
+  toVue(state?: TranslatorState): string {
+    return JSON.stringify(this);
+  }
+
+  toJS(state?: TranslatorState): string {
+    return JSON.stringify(this);
+  }
+
+  @withSourceMap()
+  toEmbeddedTS(state?: TranslatorState): string {
+    if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+      if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
+        return `${this.tsCalleeNamespace}.${this.typeName}`;
+      }
+      return `${this.tsCalleeNamespace}.${this.typeName}`;
     }
-
-    static createTypeParam(typeName: string, source?: Partial<TypeAnnotation>) {
-        return this.from(Object.assign({
-            typeKind: 'typeParam',
-            typeName,
-        }, source));
+    if (this.typeKind === 'generic') {
+      let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
+      (this.typeArguments || []).forEach((arg, index) => {
+        code += arg.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        if (index !== this.typeArguments.length - 1) code += ', ';
+      });
+      code += '>';
+      return code;
     }
-
-    static createTypeAnonymousStructure(properties: Array<StructureProperty>, source?: Partial<TypeAnnotation>) {
-        return this.from(Object.assign({
-            typeKind: 'anonymousStructure',
-            properties,
-        }, source));
+    if (this.typeKind === 'union') {
+      let code = '';
+      (this.typeArguments || []).forEach((arg, index) => {
+        code += arg.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        if (index !== this.typeArguments.length - 1) code += ' | ';
+      });
+      return code;
     }
-    /**
-     * 设置类型属性名称
-     */
-    setTypeName(typeName: string) {
-        const object = {
-            typeName,
-        };
-        this.update({
-            ...object,
-        });
+    if (this.typeKind === 'anonymousStructure') {
+      let code = `{ `;
+      (this.properties || []).forEach((property, i) => {
+        code += `${property.name}: `;
+        code += `${property.typeAnnotation
+          ? property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 }))
+          : '`未知`'
+          }`;
+        code += ', ';
+      });
+      code += `__name: "AStructure_${this.hash}" `;
+      code += ' }';
+      return code;
     }
-
-    /**
-     * 设置类型属性名称
-     */
-    setTypeNamespace(typeNamespace: string) {
-        const object = {
-            typeNamespace,
-        };
-        this.update({
-            ...object,
-        });
+    if (this.tsCalleeNamespace && this.typeName) {
+      return `${this.tsCalleeNamespace}.${this.typeName}`;
     }
-
-    get tsCalleeNamespace() {
-        if (this.typeNamespace) {
-            let tsCalleeNamespace = this.typeNamespace;
-            tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
-            tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
-            return tsCalleeNamespace;
-        }
-        return '';
+    if (this.typeName) {
+      return this.typeName;
     }
-
-    toVue(state?: TranslatorState): string {
-        return JSON.stringify(this);
+    return '__IDENTIFIER__';
+  }
+
+  @withSourceMap()
+  toNaturalTS(state?: TranslatorState): string {
+    if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+      if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
+        return this.tsCalleeNamespace.startsWith('nasl.ui') ? `${this.tsCalleeNamespace}.${this.typeName}` : `${this.typeName}`;
+      }
+      return this.tsCalleeNamespace.startsWith('nasl.ui') ? `${this.tsCalleeNamespace}.${this.typeName}` : `${this.typeName}`;
     }
-
-    toJS(state?: TranslatorState): string {
-        return JSON.stringify(this);
+    if (this.typeKind === 'generic') {
+      let code = `${this.typeName}<`;
+      (this.typeArguments || []).forEach((arg, index) => {
+        code += arg.toNaturalTS(shiftState(state, code, { inline: true }));
+        if (index !== this.typeArguments.length - 1)
+          code += ', ';
+      });
+      code += '>';
+      return code;
     }
-
-    @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
-            if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
-                return `${this.tsCalleeNamespace}.${this.typeName}`;
-            }
-            return `${this.tsCalleeNamespace}.${this.typeName}`;
-        } else if (this.typeKind === 'generic') {
-            let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
-            (this.typeArguments || []).forEach((arg, index) => {
-                code += arg.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                if (index !== this.typeArguments.length - 1)
-                    code += ', ';
-            });
-            code += '>';
-            return code;
-        } else if (this.typeKind === 'union') {
-            let code = '';
-            (this.typeArguments || []).forEach((arg, index) => {
-                code += arg.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                if (index !== this.typeArguments.length - 1)
-                    code += ' | ';
-            });
-            return code;
-        } else if (this.typeKind === 'anonymousStructure') {
-            let code = `{ `;
-            (this.properties || []).forEach((property, i) => {
-                code += `${property.name}: `;
-                code += `${property.typeAnnotation ? property.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true, tabSize: (state?.tabSize || 0) + 1 })) : '`未知`'}`;
-                code += ', ';
-            });
-            code += `__name: "AStructure_${this.hash}" `;
-            code += ' }';
-            return code;
-        } else {
-            if (this.tsCalleeNamespace && this.typeName) {
-                return `${this.tsCalleeNamespace}.${this.typeName}`;
-            } else if (this.typeName) {
-                return this.typeName;
-            } else {
-                return '__IDENTIFIER__';
-            }
-        }
+    if (this.typeKind === 'union') {
+      let code = '';
+      (this.typeArguments || []).forEach((arg, index) => {
+        code += arg.toNaturalTS(shiftState(state, code, { inline: true }));
+        if (index !== this.typeArguments.length - 1)
+          code += ' | ';
+      });
+      return code;
     }
-
-    /**
-     * 用于标准化数据结构，便于计算 anonymousStructure 的 __name
-     */
-    get anonymousStructureTypeDesc(): string {
-        if (this.typeKind === 'generic') {
-            return `${this.typeName}<${this.typeArguments.map((arg) => arg.anonymousStructureTypeDesc || arg.name || 'T').join(', ')}>`;
-        } else if (this.typeKind === 'anonymousStructure') {
-            return `{ ${[...this.properties].sort(({ name: aName }, { name: bName }) => {
-                if (aName > bName)
-                    return 1;
-                return aName < bName ? -1 : 0;
-            }).map(({ name, typeAnnotation }) =>
-                (`${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : '未知'}`)).join(', ')} }`;
-        } else {
-            return this.typeName;
-        }
+    if (this.typeKind === 'anonymousStructure') {
+      let code = `{ `;
+      (this.properties || []).forEach((property, i) => {
+        code += `${property.name}: `;
+        code += `${property.typeAnnotation.toNaturalTS(shiftState(state, code, { inline: true, tabSize: state.tabSize + 1 }))}`;
+        code += i < this.properties?.length - 1 ? ', ' : ' }';
+      });
+      return code;
     }
-
-    /**
-     * hash 用于比较 anonymousStructure 是否相同
-     */
-    get hash(): string {
-        return genHash(this.anonymousStructureTypeDesc);
+    if (this.tsCalleeNamespace && this.typeName) {
+      return `${this.typeName}`;
     }
-
-    getDefaultValue(value: string) {
-        let code = '';
-        if (this.typeKind === 'primitive') {
-            if (this.typeName === 'String') {
-                code = `   new nasl.core.String("${value}") `;
-            } else {
-                if (['Text'].includes(this.typeName)) {
-                    code = `  new ${this.typeNamespace}.${this.typeName}("${value}")`;
-                } else if (['Boolean'].includes(this.typeName)) {
-                    code = value;
-                } else {
-                    code = ` new ${this.typeNamespace}.${this.typeName}(${value})`;
-                }
-            }
-        } else {
-            code = ` ${this.typeNamespace}.${this.typeName}['${value}']`;
-        }
-
-        return code;
+    if (this.typeName) {
+      return this.typeName;
+    }
+    return '__IDENTIFIER__';
+  }
+
+  /**
+   * 用于标准化数据结构，便于计算 anonymousStructure 的 __name
+   */
+  get anonymousStructureTypeDesc(): string {
+    if (this.typeKind === 'generic') {
+      return `${this.typeName}<${this.typeArguments.map((arg) => arg.anonymousStructureTypeDesc || arg.name || 'T').join(', ')}>`;
+    }
+    if (this.typeKind === 'anonymousStructure') {
+      return `{ ${[...this.properties]
+        .sort(({ name: aName }, { name: bName }) => {
+          if (aName > bName) return 1;
+          return aName < bName ? -1 : 0;
+        })
+        .map(({ name, typeAnnotation }) => `${name}: ${typeAnnotation ? typeAnnotation.anonymousStructureTypeDesc : '未知'}`)
+        .join(', ')} }`;
+    }
+    return this.typeName;
+  }
+
+  /**
+   * hash 用于比较 anonymousStructure 是否相同
+   */
+  get hash(): string {
+    return genHash(this.anonymousStructureTypeDesc);
+  }
+
+  getDefaultValue(value: string) {
+    let code = '';
+    if (this.typeKind === 'primitive') {
+      if (this.typeName === 'String') {
+        code = `   new nasl.core.String("${value}") `;
+      } else if (['Text'].includes(this.typeName)) {
+        code = `  new ${this.typeNamespace}.${this.typeName}("${value}")`;
+      } else if (['Boolean'].includes(this.typeName)) {
+        code = value;
+      } else {
+        code = ` new ${this.typeNamespace}.${this.typeName}(${value})`;
+      }
+    } else {
+      code = ` ${this.typeNamespace}.${this.typeName}['${value}']`;
     }
 
-    /**
-     *
-     * @param code 233
-     *
-     */
-    static recognize(code: string | number): TypeAnnotation {
-        if (typeof code === 'string') {
-            const EmailReg = /^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
-            const TimeReg = /^(\d{1,2})(:\d{1,2})?:(\d{1,2})$/;
-            const DateReg = /^\d{1,4}(\/|-)\d{1,2}(\/|-)\d{1,2}$/;
-            const DateTimeReg = /^\d{1,4}(\/|-)\d{1,2}(\/|-)\d{1,2}\s(\d{1,2})(:\d{1,2})?:(\d{1,2})$/;
-            const BooleanReg = /(false|true|\u662f|\u5426)/i;
-            if (EmailReg.test(code)) {
-                return this.createPrimitive('String');
-            } else if (TimeReg.test(code)) {
-                return this.createPrimitive('Time');
-            } else if (BooleanReg.test(code)) {
-                return this.createPrimitive('Boolean');
-            } else if (DateReg.test(code)) {
-                return this.createPrimitive('Date');
-            } else if (DateTimeReg.test(code)) {
-                return this.createPrimitive('DateTime');
-            } else if (!isNaN(Number(code))) {
-                if (code.indexOf('.') !== -1) {
-                    return this.createPrimitive('Decimal');
-                    // return this.createPrimitive('Decimal');
-                }
-                if (code.length > 8) {
-                    return this.createPrimitive('Long');
-                }
-                return this.createPrimitive('Long');
-            } else if (code.length > 255) {
-                return this.createPrimitive('String');
-            }
-            return this.createPrimitive('String');
-        } else {
-            return this.createPrimitive('Long');
+    return code;
+  }
+
+  /**
+   *
+   * @param code 233
+   *
+   */
+  static recognize(code: string | number): TypeAnnotation {
+    if (typeof code === 'string') {
+      const EmailReg = /^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
+      const TimeReg = /^(\d{1,2})(:\d{1,2})?:(\d{1,2})$/;
+      const DateReg = /^\d{1,4}(\/|-)\d{1,2}(\/|-)\d{1,2}$/;
+      const DateTimeReg = /^\d{1,4}(\/|-)\d{1,2}(\/|-)\d{1,2}\s(\d{1,2})(:\d{1,2})?:(\d{1,2})$/;
+      const BooleanReg = /(false|true|\u662f|\u5426)/i;
+      if (EmailReg.test(code)) {
+        return this.createPrimitive('String');
+      }
+      if (TimeReg.test(code)) {
+        return this.createPrimitive('Time');
+      }
+      if (BooleanReg.test(code)) {
+        return this.createPrimitive('Boolean');
+      }
+      if (DateReg.test(code)) {
+        return this.createPrimitive('Date');
+      }
+      if (DateTimeReg.test(code)) {
+        return this.createPrimitive('DateTime');
+      }
+      if (!isNaN(Number(code))) {
+        if (code.indexOf('.') !== -1) {
+          return this.createPrimitive('Decimal');
+          // return this.createPrimitive('Decimal');
         }
-    }
-    // 增加插入泛型子类型
-    typeArgumentsPush(typeItem: TypeAnnotation) {
-        if (typeItem instanceof TypeAnnotation) {
-            this.typeArguments.push(TypeAnnotation.from(typeItem, {
-                parentNode: this,
-                parentKey: 'typeArguments',
-            }));
+        if (code.length > 8) {
+          return this.createPrimitive('Long');
         }
+        return this.createPrimitive('Long');
+      }
+      if (code.length > 255) {
+        return this.createPrimitive('String');
+      }
+      return this.createPrimitive('String');
     }
-
-    // 是否是复合类型 List|Map|entities|structures
-    isComplexType() {
-        const namespaceType = this.typeNamespace?.split('.').pop();
-        return ['Map', 'List'].includes(this.typeName) || (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType));
+    return this.createPrimitive('Long');
+  }
+
+  // 增加插入泛型子类型
+  typeArgumentsPush(typeItem: TypeAnnotation) {
+    if (typeItem instanceof TypeAnnotation) {
+      this.typeArguments.push(
+        TypeAnnotation.from(typeItem, {
+          parentNode: this,
+          parentKey: 'typeArguments',
+        })
+      );
     }
-    /*  类型签名 */
-    get sign() {
-        let str: string = '';
-        if (['Map', 'List'].includes(this.typeName)) {
-            str += this.typeName + '<';
-            (this.typeArguments || []).forEach((item, index) => {
-                str += item.sign;
-                if (index + 1 !== this.typeArguments.length) {
-                    str += ',';
-                }
-            });
-            str += '>';
-        } else {
-            str += this.typeName;
+  }
+
+  // 是否是复合类型 List|Map|entities|structures
+  isComplexType() {
+    const namespaceType = this.typeNamespace?.split('.').pop();
+    return ['Map', 'List'].includes(this.typeName) || (this.typeKind === 'reference' && ['entities', 'structures'].includes(namespaceType));
+  }
+
+  /*  类型签名 */
+  get sign() {
+    let str: string = '';
+    if (['Map', 'List'].includes(this.typeName)) {
+      str += `${this.typeName}<`;
+      (this.typeArguments || []).forEach((item, index) => {
+        str += item.sign;
+        if (index + 1 !== this.typeArguments.length) {
+          str += ',';
         }
-        return str;
+      });
+      str += '>';
+    } else {
+      str += this.typeName;
     }
-
-    /* 判断2个类型是否一致 */
-    isSame(typeAnnotation: TypeAnnotation) {
-        typeAnnotation.typeArguments;
-        const typeAnnotation1 = this.toJSON();
-        const typeAnnotation2 = typeAnnotation.toJSON();
-        if (typeAnnotation1.typeArguments) {
-            typeAnnotation1.typeArguments = this.sortedTypeKey;
+    return str;
+  }
+
+  /* 判断2个类型是否一致 */
+  isSame(typeAnnotation: TypeAnnotation) {
+    typeAnnotation.typeArguments;
+    const typeAnnotation1 = this.toJSON();
+    const typeAnnotation2 = typeAnnotation.toJSON();
+    if (typeAnnotation1.typeArguments) {
+      typeAnnotation1.typeArguments = this.sortedTypeKey;
+    }
+    if (typeAnnotation2.typeArguments) {
+      typeAnnotation2.typeArguments = typeAnnotation.sortedTypeKey;
+    }
+    return JSON.stringify(typeAnnotation1) === JSON.stringify(typeAnnotation2);
+  }
+
+  // 是否包含系统类型
+  hasSystemType() {
+    const disableTypeNamespaces = ['nasl.ui', 'nasl.auth', 'nasl.http', 'nasl.process'];
+    const traverseChild = (item: TypeAnnotation, cb: (arg: TypeAnnotation) => boolean | void): boolean => {
+      const res = cb(item);
+      if (res === false) return true;
+      if (item && item.concept === 'TypeAnnotation') {
+        if (item.typeKind === 'anonymousStructure') {
+          return item.properties.some((prop) => traverseChild(prop.typeAnnotation, cb));
         }
-        if (typeAnnotation2.typeArguments) {
-            typeAnnotation2.typeArguments = typeAnnotation.sortedTypeKey;
+        if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
+          return item.typeArguments.some((arg) => traverseChild(arg, cb));
         }
-        return JSON.stringify(typeAnnotation1) === JSON.stringify(typeAnnotation2);
-    }
-
-    // 是否包含系统类型
-    hasSystemType() {
-        const disableTypeNamespaces = ['nasl.ui', 'nasl.auth', 'nasl.http', 'nasl.process']
-        const traverseChild = (item: TypeAnnotation, cb: (arg: TypeAnnotation) => (boolean | void)): boolean => {
-            const res = cb(item);
-            if (res === false) return true
-            if (item && item.concept === 'TypeAnnotation') {
-                if (item.typeKind === 'anonymousStructure') {
-                    return item.properties.some(prop => traverseChild(prop.typeAnnotation, cb))
-                } else if (item.typeArguments && ['generic', 'union'].includes(item.typeKind)) {
-                    return item.typeArguments.some((arg) => traverseChild(arg, cb));
-                }
-            }
+      }
+    };
+    let result = false;
+    traverseChild(this, (node: TypeAnnotation) => {
+      if (node.typeNamespace?.endsWith('.structures')) {
+        const structure = this.rootNode.findNodeByCompleteName(`${node.typeNamespace}.${node.typeName}`);
+        const res = !structure.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType());
+        if (res === false) {
+          result = true;
         }
-        let result = false
-        traverseChild(this, (node: TypeAnnotation) => {
-            if (node.typeNamespace?.endsWith('.structures')) {
-                const structure = this.rootNode.findNodeByCompleteName(node.typeNamespace + '.' + node.typeName)
-                const res = !structure.properties.some((prop: StructureProperty) => prop.typeAnnotation.hasSystemType())
-                if (res === false) {
-                    result = true
-                }
-                return res
-            } else if (disableTypeNamespaces.includes(node.typeNamespace)) {
-                result = true
-                return false
-            }
-        })
-        return result
-    }
-
-    //================================================================================
-    // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
-    // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-    //================================================================================
+        return res;
+      }
+      if (disableTypeNamespaces.includes(node.typeNamespace)) {
+        result = true;
+        return false;
+      }
+    });
+    return result;
+  }
+
+  //= ===============================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //= ===============================================================================
 }
 
 classMap.TypeAnnotation = TypeAnnotation;
 export default TypeAnnotation;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================