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

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

@@ -0,0 +1,399 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
+import Module from './Module__';
+import BaseNode from '../common/BaseNode';
+import TypeParam from './TypeParam__';
+import Param from './Param__';
+import Return from './Return__';
+import Variable from './Variable__';
+import LogicItem from './LogicItem__';
+/**
+ * 函数
+ */
+export declare class Function extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Function';
+    /**
+     * 函数名称
+     */
+    name: string;
+    /**
+     * 函数描述
+     */
+    description: string;
+    /**
+     * 类型参数列表
+     */
+    typeParams: Array<TypeParam>;
+    /**
+     * 输入参数列表
+     */
+    params: Array<Param>;
+    /**
+     * 输出参数列表
+     */
+    returns: Array<Return>;
+    /**
+     * 变量列表
+     */
+    variables: Array<Variable>;
+    /**
+     * 逻辑项
+     */
+    returnExpression: LogicItem;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Function>);
+    static from(source: any, parentNode?: any, parentKey?: string): Function;
+    /**
+     * 设置函数名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置函数描述
+     */
+    setDescription(description: string): void;
+    /**
+     * 设置逻辑项
+     */
+    setReturnExpression(returnExpression: LogicItem): 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;
+    getParamUniqueName(name?: string): string;
+    /**
+     * 插入输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _insertParamAt(name: string, index: number): Param;
+    /**
+     * 插入输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+    /**
+     * 插入输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _insertParamAt(param: Param, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertParamAt(name: string, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param paramOptions 输入参数参数
+     */
+    insertParamAt(paramOptions: Partial<Param>, index: number): Param;
+    /**
+     * 插入输入参数
+     * @param param 已有的输入参数实例
+     */
+    insertParamAt(param: Param, index: number): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addParam(name?: string): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param paramOptions 输入参数参数
+     */
+    _addParam(paramOptions: Partial<Param>): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param param 已有的输入参数实例
+     */
+    _addParam(param: Param): Param;
+    /**
+     * 添加输入参数
+     * @internal
+     * @param name 输入参数名称，如果不填会自动生成一个唯一名称
+     */
+    addParam(name?: string): Param;
+    /**
+     * 添加输入参数
+     * @param paramOptions 输入参数参数
+     */
+    addParam(paramOptions: Partial<Param>): Param;
+    /**
+     * 添加输入参数
+     * @param param 已有的输入参数实例
+     */
+    addParam(param: Param): Param;
+    getReturnUniqueName(name?: string): string;
+    /**
+     * 插入输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _insertReturnAt(name: string, index: number): Return;
+    /**
+     * 插入输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+    /**
+     * 插入输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _insertReturnAt(ret: Return, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    insertReturnAt(name: string, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param retOptions 输出参数参数
+     */
+    insertReturnAt(retOptions: Partial<Return>, index: number): Return;
+    /**
+     * 插入输出参数
+     * @param ret 已有的输出参数实例
+     */
+    insertReturnAt(ret: Return, index: number): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    _addReturn(name?: string): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param retOptions 输出参数参数
+     */
+    _addReturn(retOptions: Partial<Return>): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param ret 已有的输出参数实例
+     */
+    _addReturn(ret: Return): Return;
+    /**
+     * 添加输出参数
+     * @internal
+     * @param name 输出参数名称，如果不填会自动生成一个唯一名称
+     */
+    addReturn(name?: string): Return;
+    /**
+     * 添加输出参数
+     * @param retOptions 输出参数参数
+     */
+    addReturn(retOptions: Partial<Return>): Return;
+    /**
+     * 添加输出参数
+     * @param ret 已有的输出参数实例
+     */
+    addReturn(ret: Return): Return;
+    getVariableUniqueName(name?: string): string;
+    /**
+     * 插入变量
+     * @internal
+     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     */
+    _insertVariableAt(name: string, index: number): Variable;
+    /**
+     * 插入变量
+     * @internal
+     * @param variableOptions 变量参数
+     */
+    _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+    /**
+     * 插入变量
+     * @internal
+     * @param variable 已有的变量实例
+     */
+    _insertVariableAt(variable: Variable, index: number): Variable;
+    /**
+     * 插入变量
+     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     */
+    insertVariableAt(name: string, index: number): Variable;
+    /**
+     * 插入变量
+     * @param variableOptions 变量参数
+     */
+    insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+    /**
+     * 插入变量
+     * @param variable 已有的变量实例
+     */
+    insertVariableAt(variable: Variable, index: number): Variable;
+    /**
+     * 添加变量
+     * @internal
+     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     */
+    _addVariable(name?: string): Variable;
+    /**
+     * 添加变量
+     * @internal
+     * @param variableOptions 变量参数
+     */
+    _addVariable(variableOptions: Partial<Variable>): Variable;
+    /**
+     * 添加变量
+     * @internal
+     * @param variable 已有的变量实例
+     */
+    _addVariable(variable: Variable): Variable;
+    /**
+     * 添加变量
+     * @internal
+     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     */
+    addVariable(name?: string): Variable;
+    /**
+     * 添加变量
+     * @param variableOptions 变量参数
+     */
+    addVariable(variableOptions: Partial<Variable>): Variable;
+    /**
+     * 添加变量
+     * @param variable 已有的变量实例
+     */
+    addVariable(variable: Variable): Variable;
+    /**
+     * 删除类型参数
+     * @param name 类型参数名称
+     */
+    removeTypeParam(name: string): void;
+    /**
+     * 删除类型参数
+     * @param typeParam 已有的类型参数实例
+     */
+    removeTypeParam(typeParam: TypeParam): void;
+    /**
+     * 删除输入参数
+     * @param name 输入参数名称
+     */
+    removeParam(name: string): void;
+    /**
+     * 删除输入参数
+     * @param param 已有的输入参数实例
+     */
+    removeParam(param: Param): void;
+    /**
+     * 删除输出参数
+     * @param name 输出参数名称
+     */
+    removeReturn(name: string): void;
+    /**
+     * 删除输出参数
+     * @param ret 已有的输出参数实例
+     */
+    removeReturn(ret: Return): void;
+    /**
+     * 删除变量
+     * @param name 变量名称
+     */
+    removeVariable(name: string): void;
+    /**
+     * 删除变量
+     * @param variable 已有的变量实例
+     */
+    removeVariable(variable: Variable): void;
+    /**
+     * 祖先 Module
+     */
+    get module(): Module;
+    toJS(state?: TranslatorState): String;
+    getVarExistingNames(excludedList?: Array<Param | Return | Variable>): string[];
+    getNamespace(): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    toEmbeddedTSDefinition(state?: TranslatorState): TranslatorGenerator;
+    get calleeKey(): string;
+}
+export default Function;

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

@@ -0,0 +1,47 @@
+import BaseNode from '../common/BaseNode';
+/**
+ * 国际化信息
+ */
+export declare class I18nInfo extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'I18nInfo';
+    /**
+     * 是否开启
+     */
+    enabled: boolean;
+    /**
+     * locale
+     */
+    locale: string;
+    /**
+     * 国际化配置列表
+     */
+    messageMap: Map<String, Map<String, String>>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<I18nInfo>);
+    static from(source: any, parentNode?: any, parentKey?: string): I18nInfo;
+    /**
+     * 设置是否开启
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 设置locale
+     */
+    setLocale(locale: string): void;
+    toNaturalTS(state?: import("../translator").TranslatorState): string;
+    get messagesLanguageList(): string[];
+}
+export default I18nInfo;

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

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

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

@@ -0,0 +1,66 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import { TypeAnnotation } from '..';
+import { ElementToVueOptions } from './ViewElement__';
+import type View from './View__';
+import BusinessComponent from './BusinessComponent__';
+import LogicItem from './LogicItem__';
+/**
+ * 标识符
+ */
+export declare class Identifier extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Identifier';
+    /**
+     * 命名空间
+     */
+    namespace: string;
+    /**
+     * 标识符名称
+     */
+    name: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Identifier>);
+    static from(source: any, parentNode?: any, parentKey?: string): Identifier;
+    typeAnnotation: TypeAnnotation;
+    globalDataMap: {
+        [name: string]: boolean;
+    };
+    isEnum(): boolean;
+    get isFrontendVariables(): boolean;
+    toVue(options?: ElementToVueOptions): string;
+    toUI(state?: TranslatorState, hideDetails?: boolean): string;
+    get jsName(): string;
+    toJS(state?: TranslatorState): string;
+    get likeComponent(): View | BusinessComponent;
+    isViewOrGlobalDataVariable(): boolean;
+    toBrief(): string;
+    get businessComponent(): BusinessComponent;
+    toEmbeddedTS(state?: TranslatorState, options?: any): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    getValue(): any;
+    get completeName(): string;
+    /**
+     * 设置函数名称
+     */
+    setNamespace(namespace: string): void;
+    /**
+     * 设置函数名称
+     */
+    setName(name: string): void;
+    setNameAndNamespace(name: string, namespace: string): void;
+}
+export default Identifier;

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

@@ -0,0 +1,155 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import LogicItem from './LogicItem__';
+/**
+ * 条件分支
+ */
+export declare class IfStatement extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'IfStatement';
+    /**
+     * 条件表达式
+     */
+    test: LogicItem;
+    /**
+     * then
+     */
+    consequent: Array<LogicItem>;
+    /**
+     * else
+     */
+    alternate: Array<LogicItem>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<IfStatement>);
+    static from(source: any, parentNode?: any, parentKey?: string): IfStatement;
+    /**
+     * 设置条件表达式
+     */
+    setTest(test: LogicItem): void;
+    /**
+     * 设置then
+     */
+    setConsequent(consequent: Array<LogicItem>): void;
+    /**
+     * 设置else
+     */
+    setAlternate(alternate: Array<LogicItem>): void;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemInConsequentAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemInConsequentAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInConsequentAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInConsequentAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInConsequent(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInConsequent(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInConsequent(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInConsequent(logicItem: LogicItem): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertItemInAlternateAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertItemInAlternateAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertItemInAlternateAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertItemInAlternateAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addItemInAlternate(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addItemInAlternate(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addItemInAlternate(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addItemInAlternate(logicItem: LogicItem): LogicItem;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInConsequent(logicItem: LogicItem): void;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeItemInAlternate(logicItem: LogicItem): void;
+    static getDefaultOptions(): {
+        label: string;
+    };
+    toJS(state?: TranslatorState): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default IfStatement;