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

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

@@ -0,0 +1,213 @@
+import { TranslatorState } from '../translator';
+import QueryAggregateExpression from './QueryAggregateExpression__';
+import QueryFieldExpression from './QueryFieldExpression__';
+import LogicItem from './LogicItem__';
+/**
+ * 查询选择子句
+ */
+export declare class QuerySelectExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QuerySelectExpression';
+    /**
+     * distinct
+     */
+    distinct: boolean;
+    /**
+     * star
+     */
+    star: boolean;
+    /**
+     * selectElements
+     */
+    selectElements: Array<QueryAggregateExpression | QueryFieldExpression>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QuerySelectExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QuerySelectExpression;
+    /**
+     * 设置selectElements
+     */
+    setSelectElements(selectElements: Array<QueryAggregateExpression | QueryFieldExpression>): void;
+    getQueryAggregateExpressionExistingNames(excludedList?: Array<QueryAggregateExpression>): string[];
+    getQueryAggregateExpressionUniqueName(name?: string): string;
+    /**
+     * 插入查询聚合函数
+     * @internal
+     * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
+     */
+    _insertQueryAggregateExpressionAt(name: string, index: number): QueryAggregateExpression;
+    /**
+     * 插入查询聚合函数
+     * @internal
+     * @param queryAggregateExpressionOptions 查询聚合函数参数
+     */
+    _insertQueryAggregateExpressionAt(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>, index: number): QueryAggregateExpression;
+    /**
+     * 插入查询聚合函数
+     * @internal
+     * @param queryAggregateExpression 已有的查询聚合函数实例
+     */
+    _insertQueryAggregateExpressionAt(queryAggregateExpression: QueryAggregateExpression, index: number): QueryAggregateExpression;
+    /**
+     * 插入查询聚合函数
+     * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
+     */
+    insertQueryAggregateExpressionAt(name: string, index: number): QueryAggregateExpression;
+    /**
+     * 插入查询聚合函数
+     * @param queryAggregateExpressionOptions 查询聚合函数参数
+     */
+    insertQueryAggregateExpressionAt(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>, index: number): QueryAggregateExpression;
+    /**
+     * 插入查询聚合函数
+     * @param queryAggregateExpression 已有的查询聚合函数实例
+     */
+    insertQueryAggregateExpressionAt(queryAggregateExpression: QueryAggregateExpression, index: number): QueryAggregateExpression;
+    /**
+     * 添加查询聚合函数
+     * @internal
+     * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
+     */
+    _addQueryAggregateExpression(name?: string): QueryAggregateExpression;
+    /**
+     * 添加查询聚合函数
+     * @internal
+     * @param queryAggregateExpressionOptions 查询聚合函数参数
+     */
+    _addQueryAggregateExpression(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>): QueryAggregateExpression;
+    /**
+     * 添加查询聚合函数
+     * @internal
+     * @param queryAggregateExpression 已有的查询聚合函数实例
+     */
+    _addQueryAggregateExpression(queryAggregateExpression: QueryAggregateExpression): QueryAggregateExpression;
+    /**
+     * 添加查询聚合函数
+     * @internal
+     * @param name 查询聚合函数名称，如果不填会自动生成一个唯一名称
+     */
+    addQueryAggregateExpression(name?: string): QueryAggregateExpression;
+    /**
+     * 添加查询聚合函数
+     * @param queryAggregateExpressionOptions 查询聚合函数参数
+     */
+    addQueryAggregateExpression(queryAggregateExpressionOptions: Partial<QueryAggregateExpression>): QueryAggregateExpression;
+    /**
+     * 添加查询聚合函数
+     * @param queryAggregateExpression 已有的查询聚合函数实例
+     */
+    addQueryAggregateExpression(queryAggregateExpression: QueryAggregateExpression): QueryAggregateExpression;
+    getQueryFieldExpressionExistingNames(excludedList?: Array<QueryFieldExpression>): string[];
+    getQueryFieldExpressionUniqueName(name?: string): string;
+    /**
+     * 插入查询属性
+     * @internal
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    _insertQueryFieldExpressionAt(name: string, index: number): QueryFieldExpression;
+    /**
+     * 插入查询属性
+     * @internal
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    _insertQueryFieldExpressionAt(queryFieldExpressionOptions: Partial<QueryFieldExpression>, index: number): QueryFieldExpression;
+    /**
+     * 插入查询属性
+     * @internal
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    _insertQueryFieldExpressionAt(queryFieldExpression: QueryFieldExpression, index: number): QueryFieldExpression;
+    /**
+     * 插入查询属性
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    insertQueryFieldExpressionAt(name: string, index: number): QueryFieldExpression;
+    /**
+     * 插入查询属性
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    insertQueryFieldExpressionAt(queryFieldExpressionOptions: Partial<QueryFieldExpression>, index: number): QueryFieldExpression;
+    /**
+     * 插入查询属性
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    insertQueryFieldExpressionAt(queryFieldExpression: QueryFieldExpression, index: number): QueryFieldExpression;
+    /**
+     * 添加查询属性
+     * @internal
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    _addQueryFieldExpression(name?: string): QueryFieldExpression;
+    /**
+     * 添加查询属性
+     * @internal
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    _addQueryFieldExpression(queryFieldExpressionOptions: Partial<QueryFieldExpression>): QueryFieldExpression;
+    /**
+     * 添加查询属性
+     * @internal
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    _addQueryFieldExpression(queryFieldExpression: QueryFieldExpression): QueryFieldExpression;
+    /**
+     * 添加查询属性
+     * @internal
+     * @param name 查询属性名称，如果不填会自动生成一个唯一名称
+     */
+    addQueryFieldExpression(name?: string): QueryFieldExpression;
+    /**
+     * 添加查询属性
+     * @param queryFieldExpressionOptions 查询属性参数
+     */
+    addQueryFieldExpression(queryFieldExpressionOptions: Partial<QueryFieldExpression>): QueryFieldExpression;
+    /**
+     * 添加查询属性
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    addQueryFieldExpression(queryFieldExpression: QueryFieldExpression): QueryFieldExpression;
+    /**
+     * 删除查询聚合函数
+     * @param name 查询聚合函数名称
+     */
+    removeQueryAggregateExpression(name: string): void;
+    /**
+     * 删除查询聚合函数
+     * @param queryAggregateExpression 已有的查询聚合函数实例
+     */
+    removeQueryAggregateExpression(queryAggregateExpression: QueryAggregateExpression): void;
+    /**
+     * 删除查询属性
+     * @param name 查询属性名称
+     */
+    removeQueryFieldExpression(name: string): void;
+    /**
+     * 删除查询属性
+     * @param queryFieldExpression 已有的查询属性实例
+     */
+    removeQueryFieldExpression(queryFieldExpression: QueryFieldExpression): void;
+    /**
+     * 聚合函数列表
+     */
+    get selectAggregateElements(): QueryAggregateExpression[];
+    /**
+     * select字段列表
+     */
+    get selectFieldElements(): QueryFieldExpression[];
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default QuerySelectExpression;

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

@@ -0,0 +1,41 @@
+import BaseNode from '../common/BaseNode';
+/**
+ * 矩形信息
+ */
+export declare class Rect extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Rect';
+    /**
+     * x
+     */
+    x: number;
+    /**
+     * y
+     */
+    y: number;
+    /**
+     * width
+     */
+    width: number;
+    /**
+     * height
+     */
+    height: number;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Rect>);
+    static from(source: any, parentNode?: any, parentKey?: string): Rect;
+}
+export default Rect;

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

@@ -0,0 +1,120 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type EntityProperty from './EntityProperty__';
+import type StructureProperty from './StructureProperty__';
+import { Diagnostic } from '../manager/diagnostic';
+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';
+import TypeAnnotation from './TypeAnnotation__';
+import DefaultValue from './DefaultValue__';
+/**
+ * 输出参数
+ */
+export declare class Return extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Return';
+    /**
+     * 输出参数名称
+     */
+    name: string;
+    /**
+     * 输出参数描述
+     */
+    description: string;
+    /**
+     * 类型
+     */
+    typeAnnotation: TypeAnnotation;
+    /**
+     * 默认值
+     */
+    defaultValue?: DefaultValue;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Return>);
+    static from(source: any, parentNode?: any, parentKey?: string): Return;
+    /**
+     * 设置输出参数名称
+     */
+    setName(name: string): void;
+    /**
+     * 设置输出参数描述
+     */
+    setDescription(description: string): void;
+    /**
+     * 祖先 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;
+    useComponent: {
+        type: 's-member-identifier-select' | 's-enum-select' | 's-schema-select' | 's-datatype-select' | 's-options-select';
+        attrs?: any;
+    };
+    /**
+     * 自动补全的属性列表
+     */
+    completionChildren: Array<EntityProperty | StructureProperty>;
+    __aStructureError: Diagnostic | undefined;
+    toJS(state?: TranslatorState): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+    isEnum(): boolean;
+    toEmbeddedTSInProcess(state?: TranslatorState): TranslatorGenerator;
+    /**
+     * 设置数据类型
+     * @param typeAnnotation 类型标注对象
+     */
+    setDataType(typeAnnotation: TypeAnnotation): Promise<void>;
+    /**
+     * 设置数据类型
+     * @param typeAnnotation 类型唯一标识
+     */
+    setDataType(typeKey: string): Promise<void>;
+    static getDefaultOptions(): {};
+    /**
+     * 是否可编辑
+     * */
+    get readonly(): boolean;
+}
+export default Return;

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

@@ -0,0 +1,58 @@
+import type { EmbeddedTSFileGenerator } from '../utils';
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import BaseNode from '../common/BaseNode';
+/**
+ * 角色
+ */
+export declare class Role extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'Role';
+    /**
+     * 角色名称
+     */
+    name: string;
+    /**
+     * 唯一标识
+     */
+    uuid: string;
+    /**
+     * 创建时间
+     */
+    createdTime: string;
+    /**
+     * 角色描述
+     */
+    description: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<Role>);
+    static from(source: any, parentNode?: any, parentKey?: string): Role;
+    /**
+     * 设置角色名称
+     */
+    setName(name: string): void;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    get tsName(): string;
+    getNamespace(): string;
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name?: string): string;
+    toEmbeddedTSFile(): EmbeddedTSFileGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default Role;

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

@@ -0,0 +1,134 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import BaseNode from '../common/BaseNode';
+import LogicItem from './LogicItem__';
+/**
+ * 选择成员
+ */
+export declare class SelectMembers extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'SelectMembers';
+    /**
+     * hideMembers
+     */
+    hideMembers: boolean;
+    /**
+     * 根表达式
+     */
+    expression: LogicItem;
+    /**
+     * 成员表达式
+     */
+    members: Array<LogicItem>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<SelectMembers>);
+    static from(source: any, parentNode?: any, parentKey?: string): SelectMembers;
+    /**
+     * 设置hideMembers
+     */
+    setHideMembers(hideMembers: boolean): void;
+    /**
+     * 设置根表达式
+     */
+    setExpression(expression: LogicItem): void;
+    /**
+     * 设置成员表达式
+     */
+    setMembers(members: Array<LogicItem>): void;
+    getLogicItemExistingNames(excludedList?: Array<LogicItem>): string[];
+    getLogicItemUniqueName(name?: string): string;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    _insertLogicItemAt(name: string, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _insertLogicItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _insertLogicItemAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    insertLogicItemAt(name: string, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    insertLogicItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+    /**
+     * 插入逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    insertLogicItemAt(logicItem: LogicItem, index: number): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    _addLogicItem(name?: string): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItemOptions 逻辑项参数
+     */
+    _addLogicItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param logicItem 已有的逻辑项实例
+     */
+    _addLogicItem(logicItem: LogicItem): LogicItem;
+    /**
+     * 添加逻辑项
+     * @internal
+     * @param name 逻辑项名称，如果不填会自动生成一个唯一名称
+     */
+    addLogicItem(name?: string): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItemOptions 逻辑项参数
+     */
+    addLogicItem(logicItemOptions: Partial<LogicItem>): LogicItem;
+    /**
+     * 添加逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    addLogicItem(logicItem: LogicItem): LogicItem;
+    /**
+     * 删除逻辑项
+     * @param name 逻辑项名称
+     */
+    removeLogicItem(name: string): void;
+    /**
+     * 删除逻辑项
+     * @param logicItem 已有的逻辑项实例
+     */
+    removeLogicItem(logicItem: LogicItem): void;
+    get lines(): number;
+    get error(): boolean;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+}
+export default SelectMembers;

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

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

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

@@ -0,0 +1,49 @@
+import BaseNode from '../common/BaseNode';
+/**
+ * 设置器枚举选项
+ */
+export declare class SetterOption extends BaseNode {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'SetterOption';
+    /**
+     * 选项值
+     */
+    value: string;
+    /**
+     * 选项标题
+     */
+    title: string;
+    /**
+     * 选项图标
+     */
+    icon?: string;
+    /**
+     * 选项工具提示
+     */
+    tooltip?: string;
+    /**
+     * 是否显隐
+     */
+    tsIf?: string;
+    /**
+     * 是否禁用
+     */
+    tsDisabledIf?: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<SetterOption>);
+    static from(source: any, parentNode?: any, parentKey?: string): SetterOption;
+}
+export default SetterOption;