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

package/dist/src/concepts/Structure__.d.ts

@@ -0,0 +1,243 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import Module from './Module__';
+import * as types from './utils/types';
+import BaseNode from '../common/BaseNode';
+import TypeParam from './TypeParam__';
+import StructureProperty from './StructureProperty__';
+/**
+ * 数据结构
+ */
+export declare class Structure extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Structure';
+    /**
+     * 数据结构名称
+     */
+    name: string;
+    /**
+     * 数据结构描述
+     */
+    description: string;
+    /**
+     * 数据结构来源
+     */
+    origin: 'CallQueryComponent';
+    /**
+     * 类型参数列表
+     */
+    typeParams?: Array<TypeParam>;
+    /**
+     * 数据结构属性列表
+     */
+    properties: Array<StructureProperty>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Structure>);
+    static from(source: any, parentNode?: any, parentKey?: string): Structure;
+    /**
+     * 设置数据结构名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置数据结构描述
+     */
+    setDescription(description: string): void;
+    getTypeParamExistingNames(excludedList?: Array<TypeParam>): string[];
+    getTypeParamUniqueName(name?: string): string;
+    /**
+     * 插入类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    _insertTypeParamAt(name: string, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @internal
+     * @param typeParamOptions 类型参数参数
+     */
+    _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @internal
+     * @param typeParam 已有的类型参数实例
+     */
+    _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertTypeParamAt(name: string, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @param typeParamOptions 类型参数参数
+     */
+    insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
+    /**
+     * 插入类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addTypeParam(name?: string): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param typeParamOptions 类型参数参数
+     */
+    _addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param typeParam 已有的类型参数实例
+     */
+    _addTypeParam(typeParam: TypeParam): TypeParam;
+    /**
+     * 添加类型参数
+     * @internal
+     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
+     */
+    addTypeParam(name?: string): TypeParam;
+    /**
+     * 添加类型参数
+     * @param typeParamOptions 类型参数参数
+     */
+    addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
+    /**
+     * 添加类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    addTypeParam(typeParam: TypeParam): TypeParam;
+    getPropertyExistingNames(excludedList?: Array<StructureProperty>): string[];
+    getPropertyUniqueName(name?: string): string;
+    /**
+     * 插入数据结构属性
+     * @internal
+     * @param name 数据结构属性名称，如果不填会自动生成一个唯一名称
+     */
+    _insertPropertyAt(name: string, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @internal
+     * @param propertyOptions 数据结构属性参数
+     */
+    _insertPropertyAt(propertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @internal
+     * @param property 已有的数据结构属性实例
+     */
+    _insertPropertyAt(property: StructureProperty, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @param name 数据结构属性名称，如果不填会自动生成一个唯一名称
+     */
+    insertPropertyAt(name: string, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @param propertyOptions 数据结构属性参数
+     */
+    insertPropertyAt(propertyOptions: Partial<StructureProperty>, index: number): StructureProperty;
+    /**
+     * 插入数据结构属性
+     * @param property 已有的数据结构属性实例
+     */
+    insertPropertyAt(property: StructureProperty, index: number): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param name 数据结构属性名称，如果不填会自动生成一个唯一名称
+     */
+    _addProperty(name?: string): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param propertyOptions 数据结构属性参数
+     */
+    _addProperty(propertyOptions: Partial<StructureProperty>): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param property 已有的数据结构属性实例
+     */
+    _addProperty(property: StructureProperty): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @internal
+     * @param name 数据结构属性名称，如果不填会自动生成一个唯一名称
+     */
+    addProperty(name?: string): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @param propertyOptions 数据结构属性参数
+     */
+    addProperty(propertyOptions: Partial<StructureProperty>): StructureProperty;
+    /**
+     * 添加数据结构属性
+     * @param property 已有的数据结构属性实例
+     */
+    addProperty(property: StructureProperty): StructureProperty;
+    /**
+     * 删除类型参数
+     * @param name 类型参数名称
+     */
+    removeTypeParam(name: string): void;
+    /**
+     * 删除类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    removeTypeParam(typeParam: TypeParam): void;
+    /**
+     * 删除数据结构属性
+     * @param name 数据结构属性名称
+     */
+    removeProperty(name: string): void;
+    /**
+     * 删除数据结构属性
+     * @param property 已有的数据结构属性实例
+     */
+    removeProperty(property: StructureProperty): void;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    get integration(): types.SyntaxNode;
+    get tsName(): string;
+    /**
+     * 是否为连接器，连接器不允许编辑
+     */
+    get isConnector(): boolean;
+    /**
+     * 是否可编辑
+     * */
+    get readonly(): boolean;
+    deleteLogincAndModule(): void;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    getNamespace(): string;
+    getTsNamespace(): string;
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name?: string): string;
+    toEmbeddedTSFile(): EmbeddedTSFileGenerator;
+}
+export default Structure;

package/dist/src/concepts/SwitchCase__.d.ts

@@ -0,0 +1,91 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import LogicItem from './LogicItem__';
+/**
+ * 选择分支情况
+ */
+export declare class SwitchCase extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'SwitchCase';
+    /**
+     * 条件表达式
+     */
+    test: LogicItem;
+    /**
+     * then
+     */
+    consequent: Array<LogicItem>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<SwitchCase>);
+    static from(source: any, parentNode?: any, parentKey?: string): SwitchCase;
+    /**
+     * 设置条件表达式
+     */
+    setTest(test: LogicItem): void;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItem(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItem(logicItem: LogicItem): LogicItem;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItem(logicItem: LogicItem): void;
+    toJS(state?: TranslatorState, index?: number, length?: number): string;
+    toEmbeddedTS(state?: TranslatorState, isLast?: boolean): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState, isLast?: boolean, isFirst?: boolean): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default SwitchCase;

package/dist/src/concepts/SwitchSetter__.d.ts

@@ -0,0 +1,25 @@
+import BaseSetter from './BaseSetter__';
+/**
+ * 切换设置器
+ */
+export declare class SwitchSetter extends BaseSetter {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'SwitchSetter';
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<SwitchSetter>);
+    static from(source: any, parentNode?: any, parentKey?: string): SwitchSetter;
+}
+export default SwitchSetter;

package/dist/src/concepts/SwitchStatement__.d.ts

@@ -0,0 +1,90 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import SwitchCase from './SwitchCase__';
+import LogicItem from './LogicItem__';
+/**
+ * 选择分支
+ */
+export declare class SwitchStatement extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'SwitchStatement';
+    /**
+     * 选择分支情况列表
+     */
+    cases: Array<SwitchCase>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<SwitchStatement>);
+    static from(source: any, parentNode?: any, parentKey?: string): SwitchStatement;
+    /**
+     * 插入选择分支情况
+     * @internal
+     * @param switchCaseOptions 选择分支情况参数
+     */
+    _insertSwitchCaseAt(switchCaseOptions: Partial<SwitchCase>, index: number): SwitchCase;
+    /**
+     * 插入选择分支情况
+     * @internal
+     * @param switchCase 已有的选择分支情况实例
+     */
+    _insertSwitchCaseAt(switchCase: SwitchCase, index: number): SwitchCase;
+    /**
+     * 插入选择分支情况
+     * @param switchCaseOptions 选择分支情况参数
+     */
+    insertSwitchCaseAt(switchCaseOptions: Partial<SwitchCase>, index: number): SwitchCase;
+    /**
+     * 插入选择分支情况
+     * @param switchCase 已有的选择分支情况实例
+     */
+    insertSwitchCaseAt(switchCase: SwitchCase, index: number): SwitchCase;
+    /**
+     * 添加选择分支情况
+     * @internal
+     * @param switchCaseOptions 选择分支情况参数
+     */
+    _addSwitchCase(switchCaseOptions: Partial<SwitchCase>): SwitchCase;
+    /**
+     * 添加选择分支情况
+     * @internal
+     * @param switchCase 已有的选择分支情况实例
+     */
+    _addSwitchCase(switchCase: SwitchCase): SwitchCase;
+    /**
+     * 添加选择分支情况
+     * @param switchCaseOptions 选择分支情况参数
+     */
+    addSwitchCase(switchCaseOptions: Partial<SwitchCase>): SwitchCase;
+    /**
+     * 添加选择分支情况
+     * @param switchCase 已有的选择分支情况实例
+     */
+    addSwitchCase(switchCase: SwitchCase): SwitchCase;
+    /**
+     * 删除选择分支情况
+     * @param switchCase 已有的选择分支情况实例
+     */
+    removeSwitchCase(switchCase: SwitchCase): void;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toJS(state?: TranslatorState): string;
+    static getDefaultOptions(): {
+        label: string;
+        cases: {
+            concept: string;
+        }[];
+    };
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+}
+export default SwitchStatement;

package/dist/src/concepts/ThemeVariable__.d.ts

@@ -0,0 +1,29 @@
+import BaseNode from '../common/BaseNode';
+/**
+ * 主题变量
+ */
+export declare class ThemeVariable extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'ThemeVariable';
+    /**
+     * 主题变量名称
+     */
+    name: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<ThemeVariable>);
+    static from(source: any, parentNode?: any, parentKey?: string): ThemeVariable;
+}
+export default ThemeVariable;

package/dist/src/concepts/Theme__.d.ts

@@ -0,0 +1,39 @@
+import BaseNode from '../common/BaseNode';
+/**
+ * 主题
+ */
+export declare class Theme extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Theme';
+    /**
+     * 主题标题
+     */
+    title: string;
+    /**
+     * 主题变量 Map
+     */
+    variableMap: {
+        [name: string]: string;
+    };
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Theme>);
+    static from(source: any, parentNode?: any, parentKey?: string): Theme;
+    /**
+     * 设置主题标题
+     */
+    setTitle(title: string): void;
+}
+export default Theme;

package/dist/src/concepts/Transactional__.d.ts

@@ -0,0 +1,85 @@
+import Logic from './Logic__';
+import Module from './Module__';
+import Connector from './Connector__';
+import View from './View__';
+import Frontend from './Frontend__';
+import ProcessElement from './ProcessElement__';
+import Process from './Process__';
+import BaseNode from '../common/BaseNode';
+/**
+ * 事务
+ */
+export declare class Transactional extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Transactional';
+    /**
+     * 事务是否生效
+     */
+    enabled: boolean;
+    /**
+     * 事务的传播机制
+     */
+    propagation: 'REQUIRED' | 'REQUIRES_NEW' | 'SUPPORTS' | 'NOT_SUPPORTED' | 'MANDATORY' | 'NEVER';
+    /**
+     * 事务的隔离级别
+     */
+    isolation: 'DEFAULT' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE';
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Transactional>);
+    static from(source: any, parentNode?: any, parentKey?: string): Transactional;
+    /**
+     * 设置事务是否生效
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 设置事务的传播机制
+     */
+    setPropagation(propagation: 'REQUIRED' | 'REQUIRES_NEW' | 'SUPPORTS' | 'NOT_SUPPORTED' | 'MANDATORY' | 'NEVER'): void;
+    /**
+     * 设置事务的隔离级别
+     */
+    setIsolation(isolation: 'DEFAULT' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE'): void;
+    toNaturalTS(state?: import("../translator").TranslatorState): string;
+    /**
+     * 祖先 Logic
+     */
+    get logic(): Logic;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    /**
+     * 祖先 Connector
+     */
+    get connector(): Connector;
+    /**
+     * 祖先 View
+     */
+    get view(): View;
+    /**
+     * 祖先 Frontend
+     */
+    get frontend(): Frontend;
+    /**
+     * 祖先 ProcessElement
+     */
+    get processElement(): ProcessElement;
+    /**
+     * 祖先 Process
+     */
+    get process(): Process;
+}
+export default Transactional;

package/dist/src/concepts/TriggerEvent__.d.ts

@@ -0,0 +1,42 @@
+import BaseNode from '../common/BaseNode';
+import TypeAnnotation from './TypeAnnotation__';
+/**
+ * 触发器事件
+ */
+export declare abstract class TriggerEvent extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'MsgTriggerEvent' | 'InterfaceTriggerEvent';
+    /**
+     * 触发器事件名称
+     */
+    name: string;
+    /**
+     * 逻辑签名
+     */
+    callBackLogic: TypeAnnotation;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<TriggerEvent>);
+    static from(source: any, parentNode?: any, parentKey?: string): TriggerEvent;
+    /**
+     * 设置触发器事件名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置逻辑签名
+     */
+    setCallBackLogic(callBackLogic: TypeAnnotation): void;
+}
+export default TriggerEvent;