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

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

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

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

@@ -0,0 +1,50 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import QueryFieldExpression from './QueryFieldExpression__';
+import LogicItem from './LogicItem__';
+/**
+ * 查询聚合函数
+ */
+export declare class QueryAggregateExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryAggregateExpression';
+    /**
+     * 聚合属性别名
+     */
+    asName: string;
+    /**
+     * 聚合函数名称
+     */
+    aggregateName: 'COUNT' | 'COUNTD' | 'SUM' | 'AVG' | 'MAX' | 'MIN';
+    /**
+     * 聚合函数参数
+     */
+    aggregateParam: QueryFieldExpression;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryAggregateExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryAggregateExpression;
+    static getDefaultOptions(): {
+        aggregateName: string;
+        aggregateParam: {
+            concept: string;
+        };
+    };
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    setName(asName: string): void;
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default QueryAggregateExpression;

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

@@ -0,0 +1,66 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import type CallQueryComponent from './CallQueryComponent__';
+import LogicItem from './LogicItem__';
+/**
+ * 查询属性
+ */
+export declare class QueryFieldExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryFieldExpression';
+    /**
+     * isDotStar
+     */
+    isDotStar: boolean;
+    /**
+     * asName
+     */
+    asName: string;
+    /**
+     * entityAsName
+     */
+    entityAsName: string;
+    /**
+     * propertyName
+     */
+    propertyName: string;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryFieldExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryFieldExpression;
+    /**
+     * 设置entityAsName
+     */
+    setEntityAsName(entityAsName: string): void;
+    /**
+     * 设置propertyName
+     */
+    setPropertyName(propertyName: string): void;
+    get parentCallQueryComponent(): CallQueryComponent;
+    get completeName(): string;
+    static getDefaultOptions(): {
+        entityAsName: string;
+        propertyName: string;
+    };
+    setEntityAsNameAndEffect(entityAsName: string): void;
+    effect(): void;
+    setName(asName: string): void;
+    getValue(): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState, genAs?: boolean): string;
+    toNaturalSQL(state?: TranslatorState, genAs?: boolean): string;
+    toBrief(): string;
+    toTextualNASL(state?: TranslatorState, genAs?: boolean): string;
+}
+export default QueryFieldExpression;

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

@@ -0,0 +1,107 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import QueryJoinExpression from './QueryJoinExpression__';
+import LogicItem from './LogicItem__';
+/**
+ * 查询 From 子句
+ */
+export declare class QueryFromExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryFromExpression';
+    /**
+     * 实体的命名空间
+     */
+    entityNamespace: string;
+    /**
+     * 实体名称
+     */
+    entityName: string;
+    /**
+     * 别名
+     */
+    asName: string;
+    /**
+     * 查询 Join 子句列表
+     */
+    joinParts: Array<QueryJoinExpression>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryFromExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryFromExpression;
+    /**
+     * 设置实体名称
+     */
+    setEntityName(entityName: string): void;
+    /**
+     * 插入查询 Join 子句
+     * @internal
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    _insertJoinPartAt(queryJoinExpressionOptions: Partial<QueryJoinExpression>, index: number): QueryJoinExpression;
+    /**
+     * 插入查询 Join 子句
+     * @internal
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    _insertJoinPartAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
+    /**
+     * 插入查询 Join 子句
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    insertJoinPartAt(queryJoinExpressionOptions: Partial<QueryJoinExpression>, index: number): QueryJoinExpression;
+    /**
+     * 插入查询 Join 子句
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    insertJoinPartAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @internal
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    _addJoinPart(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @internal
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    _addJoinPart(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    addJoinPart(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    addJoinPart(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
+    /**
+     * 删除查询 Join 子句
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    removeJoinPart(queryJoinExpression: QueryJoinExpression): void;
+    setEntityNameAndEffect(entityName: string): void;
+    effect(): void;
+    /**
+     * 设置实体namespace属性
+     */
+    setEntityNamespace(entityNamespace: string): void;
+    get entityKey(): string;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default QueryFromExpression;

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

@@ -0,0 +1,46 @@
+import { TranslatorGenerator } from '../translator';
+import LogicItem from './LogicItem__';
+/**
+ * 查询分组
+ */
+export declare class QueryGroupByExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryGroupByExpression';
+    /**
+     * 逻辑项
+     */
+    groupElement: LogicItem;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryGroupByExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryGroupByExpression;
+    /**
+     * 设置逻辑项
+     */
+    setGroupElement(groupElement: LogicItem): void;
+    static getDefaultOptions(): {
+        groupElement: {
+            kind: string;
+            concept: string;
+        };
+    };
+    setEntityAsName(name: string): void;
+    setPropertyName(name: string): void;
+    toEmbeddedTS(state?: import("../translator").TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: import("../translator").TranslatorState): string;
+    toNaturalSQL(state?: import("../translator").TranslatorState): string;
+    toTextualNASL(state?: import("../translator").TranslatorState): string;
+}
+export default QueryGroupByExpression;

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

@@ -0,0 +1,194 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import BinaryExpression from './BinaryExpression__';
+import LogicItem from './LogicItem__';
+/**
+ * 查询 Join 子句
+ */
+export declare class QueryJoinExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryJoinExpression';
+    /**
+     * 实体的命名空间
+     */
+    entityNamespace: string;
+    /**
+     * 实体名称
+     */
+    entityName: string;
+    /**
+     * 别名
+     */
+    asName: string;
+    /**
+     * joinType
+     */
+    joinType: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+    /**
+     * 二元表达式列表
+     */
+    onExpressions: Array<BinaryExpression>;
+    /**
+     * 查询 Join 子句列表
+     */
+    joinParts: Array<QueryJoinExpression>;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryJoinExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryJoinExpression;
+    /**
+     * 设置实体名称
+     */
+    setEntityName(entityName: string): void;
+    getBinaryExpressionExistingNames(excludedList?: Array<BinaryExpression>): string[];
+    getBinaryExpressionUniqueName(name?: string): string;
+    /**
+     * 插入二元表达式
+     * @internal
+     * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
+     */
+    _insertBinaryExpressionAt(name: string, index: number): BinaryExpression;
+    /**
+     * 插入二元表达式
+     * @internal
+     * @param binaryExpressionOptions 二元表达式参数
+     */
+    _insertBinaryExpressionAt(binaryExpressionOptions: Partial<BinaryExpression>, index: number): BinaryExpression;
+    /**
+     * 插入二元表达式
+     * @internal
+     * @param binaryExpression 已有的二元表达式实例
+     */
+    _insertBinaryExpressionAt(binaryExpression: BinaryExpression, index: number): BinaryExpression;
+    /**
+     * 插入二元表达式
+     * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
+     */
+    insertBinaryExpressionAt(name: string, index: number): BinaryExpression;
+    /**
+     * 插入二元表达式
+     * @param binaryExpressionOptions 二元表达式参数
+     */
+    insertBinaryExpressionAt(binaryExpressionOptions: Partial<BinaryExpression>, index: number): BinaryExpression;
+    /**
+     * 插入二元表达式
+     * @param binaryExpression 已有的二元表达式实例
+     */
+    insertBinaryExpressionAt(binaryExpression: BinaryExpression, index: number): BinaryExpression;
+    /**
+     * 添加二元表达式
+     * @internal
+     * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
+     */
+    _addBinaryExpression(name?: string): BinaryExpression;
+    /**
+     * 添加二元表达式
+     * @internal
+     * @param binaryExpressionOptions 二元表达式参数
+     */
+    _addBinaryExpression(binaryExpressionOptions: Partial<BinaryExpression>): BinaryExpression;
+    /**
+     * 添加二元表达式
+     * @internal
+     * @param binaryExpression 已有的二元表达式实例
+     */
+    _addBinaryExpression(binaryExpression: BinaryExpression): BinaryExpression;
+    /**
+     * 添加二元表达式
+     * @internal
+     * @param name 二元表达式名称，如果不填会自动生成一个唯一名称
+     */
+    addBinaryExpression(name?: string): BinaryExpression;
+    /**
+     * 添加二元表达式
+     * @param binaryExpressionOptions 二元表达式参数
+     */
+    addBinaryExpression(binaryExpressionOptions: Partial<BinaryExpression>): BinaryExpression;
+    /**
+     * 添加二元表达式
+     * @param binaryExpression 已有的二元表达式实例
+     */
+    addBinaryExpression(binaryExpression: BinaryExpression): BinaryExpression;
+    /**
+     * 插入查询 Join 子句
+     * @internal
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    _insertJoinPartAt(queryJoinExpressionOptions: Partial<QueryJoinExpression>, index: number): QueryJoinExpression;
+    /**
+     * 插入查询 Join 子句
+     * @internal
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    _insertJoinPartAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
+    /**
+     * 插入查询 Join 子句
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    insertJoinPartAt(queryJoinExpressionOptions: Partial<QueryJoinExpression>, index: number): QueryJoinExpression;
+    /**
+     * 插入查询 Join 子句
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    insertJoinPartAt(queryJoinExpression: QueryJoinExpression, index: number): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @internal
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    _addJoinPart(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @internal
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    _addJoinPart(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @param queryJoinExpressionOptions 查询 Join 子句参数
+     */
+    addJoinPart(queryJoinExpressionOptions: Partial<QueryJoinExpression>): QueryJoinExpression;
+    /**
+     * 添加查询 Join 子句
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    addJoinPart(queryJoinExpression: QueryJoinExpression): QueryJoinExpression;
+    /**
+     * 删除二元表达式
+     * @param name 二元表达式名称
+     */
+    removeBinaryExpression(name: string): void;
+    /**
+     * 删除二元表达式
+     * @param binaryExpression 已有的二元表达式实例
+     */
+    removeBinaryExpression(binaryExpression: BinaryExpression): void;
+    /**
+     * 删除查询 Join 子句
+     * @param queryJoinExpression 已有的查询 Join 子句实例
+     */
+    removeJoinPart(queryJoinExpression: QueryJoinExpression): void;
+    get entityKey(): string;
+    setEntityNameAndEffect(entityName: string): void;
+    effect(): void;
+    /**
+     * 设置实体namespace属性
+     */
+    setEntityNamespace(entityNamespace: string): void;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default QueryJoinExpression;

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

@@ -0,0 +1,46 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import LogicItem from './LogicItem__';
+/**
+ * 查询分页子句
+ */
+export declare class QueryLimitExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryLimitExpression';
+    /**
+     * 逻辑项
+     */
+    pageElement: LogicItem;
+    /**
+     * 逻辑项
+     */
+    pageSizeElement: LogicItem;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryLimitExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryLimitExpression;
+    /**
+     * 设置逻辑项
+     */
+    setPageElement(pageElement: LogicItem): void;
+    /**
+     * 设置逻辑项
+     */
+    setPageSizeElement(pageSizeElement: LogicItem): void;
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default QueryLimitExpression;

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

@@ -0,0 +1,57 @@
+import { TranslatorState, TranslatorGenerator } from '../translator';
+import LogicItem from './LogicItem__';
+/**
+ * 查询排序子句
+ */
+export declare class QueryOrderByExpression extends LogicItem {
+    /** 类名 */
+    static readonly ConceptName: string;
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static isAbstract: boolean;
+    /** 继承链 */
+    static readonly inheritanceChain: string[];
+    /**
+     * 产品概念
+     */
+    readonly concept: 'QueryOrderByExpression';
+    /**
+     * 逻辑项
+     */
+    orderElement: LogicItem;
+    /**
+     * 逻辑项
+     */
+    order: LogicItem;
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source?: Partial<QueryOrderByExpression>);
+    static from(source: any, parentNode?: any, parentKey?: string): QueryOrderByExpression;
+    /**
+     * 设置逻辑项
+     */
+    setOrderElement(orderElement: LogicItem): void;
+    /**
+     * 设置逻辑项
+     */
+    setOrder(order: LogicItem): void;
+    static getDefaultOptions(): {
+        concept: string;
+        label: string;
+        orderElement: {
+            concept: string;
+        };
+        order: {
+            concept: string;
+            value: string;
+        };
+    };
+    toEmbeddedTS(state?: TranslatorState): TranslatorGenerator;
+    toNaturalTS(state?: TranslatorState): string;
+    toNaturalSQL(state?: TranslatorState): string;
+    toTextualNASL(state?: TranslatorState): string;
+}
+export default QueryOrderByExpression;