@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/sandbox/stdlib/nasl.processV2.ts

@@ -55,10 +55,10 @@ declare namespace nasl.processV2 {
   export function getProcInstInfo(taskId: nasl.core.String): ProcInstInfo;
 
   //同意
-  export function approveTask(data: void, procDefKey: nasl.core.String, taskId: nasl.core.String, nodeOperationComment: nasl.core.String): void;
+  export function approveTask(data: void, procDefKey: nasl.core.String, taskId: nasl.core.String, comment: nasl.core.String): void;
 
   //拒绝
-  export function rejectTask(data: void, procDefKey: nasl.core.String, taskId: nasl.core.String, nodeOperationComment: nasl.core.String): void;
+  export function rejectTask(data: void, procDefKey: nasl.core.String, taskId: nasl.core.String, comment: nasl.core.String): void;
 
   //提交
   export function submitTask(data: void, procDefKey: nasl.core.String, taskId: nasl.core.String): void;
@@ -87,6 +87,9 @@ declare namespace nasl.processV2 {
   //撤回
   export function withdrawTask(taskId: nasl.core.String): void;
 
+  // 加签
+  export function addSignTask(taskId: nasl.core.String, userForAddSign: nasl.core.String): void;
+
   //终止
   export function terminateProcess(procInstId: nasl.core.String): void;
 
@@ -262,8 +265,10 @@ declare namespace nasl.processV2 {
     }
   }
 
-  export enum ProcInstStatusEnum {
-    'Approved' = '审批通过',
-    'Approving' = '审批中',
+  namespace enums {
+    export enum ProcInstStatusEnum {
+      'Approved' = '审批结束',
+      'Approving' = '审批中',
+    }
   }
 }

package/sandbox/stdlib/nasl.util.ts

@@ -139,7 +139,9 @@ declare namespace nasl.util {
   export function MapTransformAsync<K0, V0, K extends nasl.core.Boolean | nasl.core.Long | nasl.core.Decimal | nasl.core.String, V>(map: nasl.collection.Map<K0, V0>, byKey: (key: K0, value: V0) => K, byVal: (key: K0, value: V0) => V): nasl.collection.Map<K, V>;
   export function ListToMapAsync<T, K extends nasl.core.Boolean | nasl.core.Long | nasl.core.Decimal | nasl.core.String, V>(map: nasl.collection.List<T>, byKey: (elem: T) => K, byVal: (elem: T) => V): nasl.collection.Map<K, V>;
 
-  // 处理携带了 Error 的类型，去除掉 Error 然后返回
+  // 处理携带了error的类型，去除掉error然后返回
+  export function autoTypeHandleError<T>(value: T): Exclude<T, nasl.ui.Error>;
+  // 处理函数 携带了 Error 的类型，传入函数， 去除掉 返回值 Error 然后返回
   export function autoHandleError<T extends (...args: any[]) => any>(func: T): (...args: Parameters<T>) => Exclude<ReturnType<T>, nasl.ui.Error>;
   // 逻辑调用和验证器函数的包装器
   export function callLogicWithChecker<T extends (...args: any[]) => any>(func: T, checker: (...args: Parameters<T>) => any): T;

package/src/automate/engine/utils.js

@@ -1,4 +1,4 @@
-import { BaseNode, uiStructures, collectionStructures, configurationEnums, interfaceStructures, processStructures, getStdlibNamespace, processV2Structures, coreStructures, authStructures, httpStructures } from '../../concepts';
+import { BaseNode, uiStructures, collectionStructures, configurationEnums, processV2Enums, interfaceStructures, processStructures, getStdlibNamespace, processV2Structures, coreStructures, authStructures, httpStructures } from '../../concepts';
 import { getConceptMeta } from '../../decorators/index';
 /*
     根据 namespace 字符串来获取 node
@@ -83,7 +83,12 @@ export function getNaslNodeByNodeCallee(namespace, typeName) {
     } else if (namespace === 'nasl.process') {
         return processStructures.find((item) => item.name === typeName);
     } else if (namespace === 'nasl.processV2') {
-        return processV2Structures.find((item) => item.name === typeName);
+        console.log(123)
+        const findStructure = processV2Structures.find((item) => item.name === typeName);
+        if(findStructure) {
+            return findStructure;
+        }
+        return processV2Enums.find((item) => item.name === typeName);
     } else if (namespace === 'nasl.util') {
         const utilLogic = getStdlibNamespace().findChild('util').logics;
         return utilLogic.find((item) => item.name === typeName);

package/src/bak/translator.js

@@ -1,5 +1,5 @@
 import { PAGE_COMPONENT_INCLUDE_TAG_MAP, ComponentCompletionPropertyMap } from '..';
-import { attrConvertCamelCase } from '../utils/index'
+import { attrConvertCamelCase, getControlNode, isSelectClassComponent } from '../utils/index';
 function safeCodeAsKey(name) {
   return `['${name}']`;
 }
@@ -117,6 +117,47 @@ export default function (definition, view) {
    */
   const viewComputedData = []
   const viewMethodData = []
+
+  /**
+   * 流程表单设计器中，审批页是一个特殊的页面，需要特殊处理
+   */
+  if (view?.composedBy) {
+    const form = view.app
+      .getComposeNodes(view.composedBy)
+      .find((it) => it.name === view.composedBy[0]);
+    form.children[0].children[0].children.forEach((it) => {
+      const element = getControlNode(it.children[0]);
+      const isNeedCollect = isSelectClassComponent(element);
+      if (isNeedCollect) {
+        const attrs = element.bindAttrs;
+        attrs.forEach((attr) => {
+          let variable = '';
+          if (attr.expression) {
+            variable += `${attr.expression?.toJS()}`
+          } else if (attr.type === 'static') {
+            variable = `${attr.value}`
+          }
+          if (attr.expression?.concept === 'CallLogic' && attr.name === 'dataSource') {
+            console.log('attr', attr);
+            const currentParamsNum = element.currentIndex + 1;
+            let currentParamList = [];
+            for (let i = 0; i < currentParamsNum; i++) {
+              currentParamList.push(`,current${i === 0 ? '' : i}`);
+            }
+            const codeLoad = `async '__${
+              element.name
+            }_handleDataSourceLoad'(params${currentParamList.join('')}) {
+              this['__${element.name}_params'] = {...params};
+              return ${variable}
+            }`;
+            viewMethodData.push(codeLoad);
+          }
+        });
+        }
+    });
+  }
+
+
   // 组件数据源属性的制品翻译
   definition.elementsAll.forEach(element => {
     element.bindAttrs.forEach(attr => {

package/src/breakpoint/shared/utils.ts

@@ -27,6 +27,7 @@ type HistoryInApp = {
       oldObject?: null | Record<string, any>,
     }>,
   }>,
+  _historyName?: string;
 };
 
 const neatKeys = [
@@ -45,7 +46,7 @@ export const isAppDirty = (app: HistoryInApp = {}) => {
     _historyList = [],
   } = app;
 
-  const historyList = _historyList.slice(0, _historyIndex);
+  const historyList = Array.isArray(_historyList) ? _historyList.slice(0, _historyIndex) : [];
 
   return historyList.some((item = {}) => {
     const { list = [] } = item;

package/src/common/BaseNode.ts

@@ -30,6 +30,7 @@ const patchCompose = (node: BaseNode, type = 'add') => {
   }
 }
 
+
 type NodePathOption = {
   useName?: boolean,
 }
@@ -321,6 +322,25 @@ export class BaseNode extends EventEmitter {
       const app = (this as any)?.app;
       app && app?._action !== 'undo' && app.addComposeNodes(this.composedBy, this); // undo 操作是临时判断，无法准确判断到触发点
     }
+    if(['Entity','Logic',"ViewElement"].includes(source.concept)){
+      const app = (this as any)?.app;
+      if(app){
+        (app?.getDefaultOnAnno()?.[source.concept] as any)?.map((anno:any)=>{
+          if((this as any)?.applyAnnotations?.length>0){
+            // (this as any)?._addApplyAnnotation(anno?.transToApplyAnno())
+            (this as any)?.applyAnnotations.push(anno?.transToApplyAnno())
+          }else{
+            (this as any).applyAnnotations = [anno?.transToApplyAnno()]
+            // this.update({
+            //   applyAnnotations:[anno?.transToApplyAnno()]
+            // })
+          }
+        })
+        // this.applyAnnotations
+      }
+
+    }
+
   }
 
   fixInstantiate() {
@@ -789,9 +809,7 @@ export class BaseNode extends EventEmitter {
     // 有一些继承的情况
     const Ctor = classMap.get(source?.concept) || this;
     if (Ctor && source instanceof Ctor) {
-      if (utils.isDebugMode) {
-        console.warn('传入的对象已经是一个实例，请确认逻辑是否存在问题！');
-      }
+      console.warn('传入的对象已经是一个实例，请确认逻辑是否存在问题！')
       if (parentNode) {
         source.parentNode = parentNode;
       }
@@ -1395,7 +1413,7 @@ export class BaseNode extends EventEmitter {
       for (const property of propertyMap.keys()) {
         const child = node[property as keyof BaseNode];
         if (!child) continue;
-        else if (Array.isArray(child)) child.forEach((node: types.SyntaxNode) => traverse(node));
+        else if (Array.isArray(child)) child?.forEach?.((node: types.SyntaxNode) => traverse(node));
         else traverse(child);
       }
     }
@@ -1648,6 +1666,86 @@ export class BaseNode extends EventEmitter {
     return traverse(this as unknown as types.SyntaxNode);
   }
 
+  /**
+   * 广度遍历子节点，如果当前节点满足pre 函数，将不会再向下遍历
+   * @param input 搜索条件
+   * @param containsSelf: 是否包含自身
+   * @returns 搜索到的节点
+   */
+  findNaslNodeByBFS(input?: types.SyntaxNodeConcept | ((node: types.SyntaxNode) => boolean), containsSelf = false) {
+    const pre =
+      typeof input === 'undefined'
+        ? (node: types.SyntaxNode) => asserts.isBaseNode(node)
+        : typeof input === 'string'
+          ? (node: types.SyntaxNode) => asserts[`isStrict${input}`]?.(node) ?? false
+          : input;
+
+    const queue: types.SyntaxNode[] = []; // 创建一个队列存储待遍历的节点
+    const results: types.SyntaxNode[] = []; // 创建一个数组存储匹配的结果
+
+    queue.push(this as unknown as types.SyntaxNode); // 将初始节点加入队列
+
+    while (queue.length > 0) {
+      const node = queue.shift(); // 从队列中取出一个节点
+
+      if (node) {
+        let result = false;
+        if (!containsSelf) {
+          result = node !== this && Boolean(node) && pre(node);
+        } else {
+          result = Boolean(node) && pre(node);
+        }
+
+        if (result) {
+          results.push(node); // 如果pre函数返回true，则将节点添加到结果数组
+          continue; // 继续下一次循环，继续遍历同层级的其他节点
+        }
+
+        const propertyMap = getConceptPropertyMap(node?.concept);
+
+        if (!propertyMap) {
+          continue; // 如果没有属性映射，则继续下一次循环
+        }
+
+        for (const property of propertyMap.keys()) {
+          const child = node[property as keyof BaseNode];
+
+          // 如果子节点不存在，则继续下一次循环
+          if (!child) {
+            continue; // 如果子节点不存在，则继续下一次循环
+          }
+          else if (Array.isArray(child)) {
+            for (const item of child) {
+              const itemResult = Boolean(item) && pre(item);
+
+              if (itemResult) {
+                results.push(item); // 如果pre函数返回true，则将节点添加到结果数组
+                continue; // 继续下一次循环，继续遍历同层级的其他节点；
+              }
+              // 只有节点是一个 NaslNode 才会继续遍历
+              if (asserts.isBaseNode(item)) {
+                queue.push(item as types.SyntaxNode); // 将子节点加入队列
+              }
+            }
+          }
+          else {
+            const childResult = Boolean(child) && pre(child);
+
+            if (childResult) {
+              results.push(child); // 如果pre函数返回true，则将节点添加到结果数组
+              continue;
+            }
+            if (asserts.isBaseNode(child)) {
+              queue.push(child as types.SyntaxNode); // 将子节点加入队列
+            }
+          }
+        }
+      }
+    }
+
+    return results; // 返回匹配的结果数组
+  }
+
   *toEmbeddedTS(): Generator<any, string, any> {
     return '';
   }
@@ -1667,9 +1765,23 @@ export class BaseNode extends EventEmitter {
    */
   toDebugTs() {
     utils.runGeneratorAsync(this.toEmbeddedTS()).then((data) => {
-      console.log(data);
+      console.dir(data);
     });
   }
+
+  /**
+   * 判断目标节点是否为当前节点的祖先节点
+   */
+  isAncestor(node: BaseNode) {
+    let { parentNode } = this;
+    while (parentNode) {
+      if (parentNode === node) {
+        return true;
+      }
+      parentNode = parentNode.parentNode;
+    }
+    return false;
+  }
 }
 
 export default BaseNode;

package/src/concepts/Annotatable__.ts

@@ -0,0 +1,263 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import { createUUID } from '../utils/create';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import BaseNode from '../common/BaseNode';
+import ApplyAnnotation from './ApplyAnnotation__';
+
+/**
+ * 可使用注解
+ */
+@concept('可使用注解')
+export abstract class Annotatable extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'Annotatable';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = true;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!:
+    | 'Entity'
+    | 'View'
+    | 'ViewElement'
+    | 'Logic'
+    | 'AuthLogic'
+    | 'AuthLogicForCallInterface'
+    | 'BusinessLogic'
+    | 'ConnectorLogic';
+  /**
+   * 注解列表
+   */
+  @property({
+    objectRef: 'ApplyAnnotation',
+    isArray: true,
+    defaultValue: null,
+  })
+  applyAnnotations?: Array<ApplyAnnotation>;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<Annotatable>) {
+    source = Object.assign({}, Annotatable.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): Annotatable {
+    return super.from(source, parentNode, parentKey) as Annotatable;
+  }
+
+  getApplyAnnotationExistingNames(excludedList: Array<ApplyAnnotation> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.applyAnnotations as ApplyAnnotation[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
+  }
+  getApplyAnnotationUniqueName(name = 'applyAnnotation1') {
+    return utils.unique(name, this.getApplyAnnotationExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入使用注解
+   * @internal
+   * @param name 使用注解名称，如果不填会自动生成一个唯一名称
+   */
+  _insertApplyAnnotationAt(name: string, index: number): ApplyAnnotation;
+
+  /**
+   * 插入使用注解
+   * @internal
+   * @param applyAnnotationOptions 使用注解参数
+   */
+  _insertApplyAnnotationAt(applyAnnotationOptions: Partial<ApplyAnnotation>, index: number): ApplyAnnotation;
+
+  /**
+   * 插入使用注解
+   * @internal
+   * @param applyAnnotation 已有的使用注解实例
+   */
+  _insertApplyAnnotationAt(applyAnnotation: ApplyAnnotation, index: number): ApplyAnnotation;
+
+  _insertApplyAnnotationAt(options: string | Partial<ApplyAnnotation> | ApplyAnnotation, index: number) {
+    const applyAnnotationOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'applyAnnotations' };
+    const ApplyAnnotation = getConceptConstructor('ApplyAnnotation');
+    let applyAnnotation: ApplyAnnotation;
+    if (!options) {
+      applyAnnotation = ApplyAnnotation.from(
+        {
+          ...applyAnnotationOptions,
+          name: this.getApplyAnnotationUniqueName(),
+        },
+        this,
+        'applyAnnotations',
+      );
+    } else if (typeof options === 'string') {
+      applyAnnotation = ApplyAnnotation.from(
+        {
+          ...applyAnnotationOptions,
+          name: options,
+        },
+        this,
+        'applyAnnotations',
+      );
+    } else if (asserts.isApplyAnnotation(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      applyAnnotation = options;
+      Object.assign(applyAnnotation, relationOptions);
+    } else {
+      applyAnnotation = ApplyAnnotation.from(
+        {
+          ...applyAnnotationOptions,
+          ...options,
+        },
+        this,
+        'applyAnnotations',
+      );
+    }
+    this.applyAnnotations.splice(index, 0, applyAnnotation);
+    return applyAnnotation;
+  }
+
+  /**
+   * 插入使用注解
+   * @param name 使用注解名称，如果不填会自动生成一个唯一名称
+   */
+  insertApplyAnnotationAt(name: string, index: number): ApplyAnnotation;
+
+  /**
+   * 插入使用注解
+   * @param applyAnnotationOptions 使用注解参数
+   */
+  insertApplyAnnotationAt(applyAnnotationOptions: Partial<ApplyAnnotation>, index: number): ApplyAnnotation;
+
+  /**
+   * 插入使用注解
+   * @param applyAnnotation 已有的使用注解实例
+   */
+  insertApplyAnnotationAt(applyAnnotation: ApplyAnnotation, index: number): ApplyAnnotation;
+
+  insertApplyAnnotationAt(options: string | Partial<ApplyAnnotation> | ApplyAnnotation, index: number) {
+    const node = this._insertApplyAnnotationAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'applyAnnotations',
+    });
+    return node;
+  }
+
+  /**
+   * 添加使用注解
+   * @internal
+   * @param name 使用注解名称，如果不填会自动生成一个唯一名称
+   */
+  _addApplyAnnotation(name?: string): ApplyAnnotation;
+
+  /**
+   * 添加使用注解
+   * @internal
+   * @param applyAnnotationOptions 使用注解参数
+   */
+  _addApplyAnnotation(applyAnnotationOptions: Partial<ApplyAnnotation>): ApplyAnnotation;
+
+  /**
+   * 添加使用注解
+   * @internal
+   * @param applyAnnotation 已有的使用注解实例
+   */
+  _addApplyAnnotation(applyAnnotation: ApplyAnnotation): ApplyAnnotation;
+
+  _addApplyAnnotation(options?: string | Partial<ApplyAnnotation> | ApplyAnnotation) {
+    const index = this.applyAnnotations.length;
+    return this._insertApplyAnnotationAt(options as any, index);
+  }
+
+  /**
+   * 添加使用注解
+   * @internal
+   * @param name 使用注解名称，如果不填会自动生成一个唯一名称
+   */
+  addApplyAnnotation(name?: string): ApplyAnnotation;
+
+  /**
+   * 添加使用注解
+   * @param applyAnnotationOptions 使用注解参数
+   */
+  addApplyAnnotation(applyAnnotationOptions: Partial<ApplyAnnotation>): ApplyAnnotation;
+
+  /**
+   * 添加使用注解
+   * @param applyAnnotation 已有的使用注解实例
+   */
+  addApplyAnnotation(applyAnnotation: ApplyAnnotation): ApplyAnnotation;
+
+  addApplyAnnotation(options?: string | Partial<ApplyAnnotation> | ApplyAnnotation) {
+    const node = this._addApplyAnnotation(options as any);
+    const index = this.applyAnnotations.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'applyAnnotations',
+    });
+    return node;
+  }
+
+  /**
+   * 删除使用注解
+   * @param name 使用注解名称
+   */
+  removeApplyAnnotation(name: string): void;
+
+  /**
+   * 删除使用注解
+   * @param applyAnnotation 已有的使用注解实例
+   */
+  removeApplyAnnotation(applyAnnotation: ApplyAnnotation): void;
+
+  removeApplyAnnotation(options: string | ApplyAnnotation) {
+    let applyAnnotation: ApplyAnnotation;
+    if (typeof options === 'string') {
+      applyAnnotation = (this.applyAnnotations as ApplyAnnotation[]).find((item) => item.name === options);
+      if (!applyAnnotation) {
+        throw new Error('找不到使用注解 ' + options);
+      }
+    } else {
+      applyAnnotation = options;
+    }
+    return applyAnnotation.delete();
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default Annotatable;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/AnnotationProperty__.ts

@@ -0,0 +1,102 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import { createUUID } from '../utils/create';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import BaseNode from '../common/BaseNode';
+import TypeAnnotation from './TypeAnnotation__';
+import BaseSetter from './BaseSetter__';
+import DefaultValue from './DefaultValue__';
+
+/**
+ * 注解属性
+ */
+@concept('注解属性')
+export class AnnotationProperty extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'AnnotationProperty';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'AnnotationProperty';
+  /**
+   * 注解属性名称
+   */
+  @property()
+  name: string;
+
+  /**
+   * 注解属性标题
+   */
+  @property()
+  title: string;
+
+  /**
+   * 注解属性类型
+   */
+  @property({
+    objectRef: 'TypeAnnotation',
+  })
+  typeAnnotation: TypeAnnotation;
+
+  /**
+   * 设置器
+   */
+  @property({
+    objectRef: 'BaseSetter',
+  })
+  setter: BaseSetter;
+
+  /**
+   * 注解属性默认值
+   */
+  @property({
+    objectRef: 'DefaultValue',
+  })
+  defaultValue?: DefaultValue;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<AnnotationProperty>) {
+    source = Object.assign({}, AnnotationProperty.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): AnnotationProperty {
+    return super.from(source, parentNode, parentKey) as AnnotationProperty;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default AnnotationProperty;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================