import { TranslatorState, TranslatorGenerator } from '@lcap/nasl-translator';
import type QueryJoinExpression from './QueryJoinExpression__';
import type Entity from './Entity__';
import type Structure from './Structure__';
import type StructureProperty from './StructureProperty__';
import type CompletionProperty from './CompletionProperty__';
import type Identifier from './Identifier__';
import type MemberExpression from './MemberExpression__';
import type TypeAnnotation from './TypeAnnotation__';
import * as types from './utils/types';
import LogicItem from './LogicItem__';
import type QuerySelectExpression from './QuerySelectExpression__';
import type QueryFromExpression from './QueryFromExpression__';
import type QueryGroupByExpression from './QueryGroupByExpression__';
import type QueryOrderByExpression from './QueryOrderByExpression__';
import type QueryLimitExpression from './QueryLimitExpression__';
/**
 * 数据查询
 */
export declare class CallQueryComponent extends LogicItem {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'CallQueryComponent';
    /**
     * select
     */
    select: QuerySelectExpression;
    /**
     * from
     */
    from: QueryFromExpression;
    /**
     * where
     */
    where?: types.LogicItemNode;
    /**
     * where 草稿态
     */
    wherePlayground: Array<types.LogicItemNode>;
    /**
     * groupBy
     */
    groupBy: Array<QueryGroupByExpression>;
    /**
     * having
     */
    having?: types.LogicItemNode;
    /**
     * having 草稿态
     */
    havingPlayground: Array<types.LogicItemNode>;
    /**
     * orderBy
     */
    orderBy: Array<QueryOrderByExpression>;
    /**
     * limit
     */
    limit?: QueryLimitExpression;
    /**
     * 查询组件的局部版本
     */
    ideVersion: string;
    /**
     * 简化返回类型
     */
    simplifyType?: boolean;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<CallQueryComponent>);
    static from(source: any, parentNode?: any, parentKey?: string): CallQueryComponent;
    /**
     * 设置select
     */
    setSelect(select: QuerySelectExpression): void;
    /**
     * 设置from
     */
    setFrom(from: QueryFromExpression): void;
    /**
     * 设置where
     */
    setWhere(where: types.LogicItemNode): void;
    /**
     * 设置groupBy
     */
    setGroupBy(groupBy: Array<QueryGroupByExpression>): void;
    /**
     * 设置having
     */
    setHaving(having: types.LogicItemNode): void;
    /**
     * 设置orderBy
     */
    setOrderBy(orderBy: Array<QueryOrderByExpression>): void;
    /**
     * 设置limit
     */
    setLimit(limit: QueryLimitExpression): void;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _insertItemInWherePlaygroundAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _insertItemInWherePlaygroundAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    insertItemInWherePlaygroundAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    insertItemInWherePlaygroundAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _addItemInWherePlayground(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _addItemInWherePlayground(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    addItemInWherePlayground(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    addItemInWherePlayground(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _insertItemInHavingPlaygroundAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _insertItemInHavingPlaygroundAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    insertItemInHavingPlaygroundAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    insertItemInHavingPlaygroundAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _addItemInHavingPlayground(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _addItemInHavingPlayground(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    addItemInHavingPlayground(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    addItemInHavingPlayground(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 插入查询分组
     * @internal
     * @param queryGroupByExpressionOptions 查询分组参数
     */
    _insertQueryGroupByExpressionAt(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>, index: number): QueryGroupByExpression;
    /**
     * 插入查询分组
     * @internal
     * @param queryGroupByExpression 已有的查询分组实例
     */
    _insertQueryGroupByExpressionAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
    /**
     * 插入查询分组
     * @param queryGroupByExpressionOptions 查询分组参数
     */
    insertQueryGroupByExpressionAt(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>, index: number): QueryGroupByExpression;
    /**
     * 插入查询分组
     * @param queryGroupByExpression 已有的查询分组实例
     */
    insertQueryGroupByExpressionAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
    /**
     * 添加查询分组
     * @internal
     * @param queryGroupByExpressionOptions 查询分组参数
     */
    _addQueryGroupByExpression(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>): QueryGroupByExpression;
    /**
     * 添加查询分组
     * @internal
     * @param queryGroupByExpression 已有的查询分组实例
     */
    _addQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
    /**
     * 添加查询分组
     * @param queryGroupByExpressionOptions 查询分组参数
     */
    addQueryGroupByExpression(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>): QueryGroupByExpression;
    /**
     * 添加查询分组
     * @param queryGroupByExpression 已有的查询分组实例
     */
    addQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
    /**
     * 插入查询排序子句
     * @internal
     * @param queryOrderByExpressionOptions 查询排序子句参数
     */
    _insertQueryOrderByExpressionAt(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>, index: number): QueryOrderByExpression;
    /**
     * 插入查询排序子句
     * @internal
     * @param queryOrderByExpression 已有的查询排序子句实例
     */
    _insertQueryOrderByExpressionAt(queryOrderByExpression: QueryOrderByExpression, index: number): QueryOrderByExpression;
    /**
     * 插入查询排序子句
     * @param queryOrderByExpressionOptions 查询排序子句参数
     */
    insertQueryOrderByExpressionAt(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>, index: number): QueryOrderByExpression;
    /**
     * 插入查询排序子句
     * @param queryOrderByExpression 已有的查询排序子句实例
     */
    insertQueryOrderByExpressionAt(queryOrderByExpression: QueryOrderByExpression, index: number): QueryOrderByExpression;
    /**
     * 添加查询排序子句
     * @internal
     * @param queryOrderByExpressionOptions 查询排序子句参数
     */
    _addQueryOrderByExpression(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>): QueryOrderByExpression;
    /**
     * 添加查询排序子句
     * @internal
     * @param queryOrderByExpression 已有的查询排序子句实例
     */
    _addQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
    /**
     * 添加查询排序子句
     * @param queryOrderByExpressionOptions 查询排序子句参数
     */
    addQueryOrderByExpression(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>): QueryOrderByExpression;
    /**
     * 添加查询排序子句
     * @param queryOrderByExpression 已有的查询排序子句实例
     */
    addQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
    /**
     * 删除逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    removeItemInWherePlayground(logicItem: types.LogicItemNode): void;
    /**
     * 删除逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    removeItemInHavingPlayground(logicItem: types.LogicItemNode): void;
    /**
     * 删除查询分组
     * @param queryGroupByExpression 已有的查询分组实例
     */
    removeQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): void;
    /**
     * 删除查询排序子句
     * @param queryOrderByExpression 已有的查询排序子句实例
     */
    removeQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): void;
    name?: string;
    /**
     * 获取添加时的默认选项
     * @returns
     */
    static getDefaultOptions(): any;
    toEmbeddedTSOfSubPart<T extends {
        toEmbeddedTS: (state?: TranslatorState) => TranslatorGenerator;
    }>(key: string, list: Array<T>, options: {
        code: string;
        state: TranslatorState;
        multipleErrorType?: '__WHERE_MULTIPLE_CONDITION__' | '__HAVING_MULTIPLE_CONDITION__';
    }): Generator<any, string, any>;
    entityNames(): string[];
    toUI(state?: TranslatorState, hideDetails?: boolean): string;
    toJS(): string;
    isAutoInfer(): boolean;
    get entityPropertySelectable(): boolean;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    genPropertiesFrom(node: QueryFromExpression | QueryJoinExpression, properties?: StructureProperty[]): StructureProperty[];
    genPropertyListOfFrom(node: QueryFromExpression | QueryJoinExpression, entities?: any[]): any[];
    genPropertyListOfAggregate(node: CallQueryComponent, entities: Entity[]): {
        concept: string;
        name: string;
        typeAnnotation: {
            concept: string;
            typeKind: string;
            typeNamespace: string;
            typeName: string;
        };
    }[];
    genPropertyListOfGroupBy(node: CallQueryComponent, entities: Entity[]): {
        concept: string;
        name: string;
        typeAnnotation: {
            concept: "TypeAnnotation";
            typeKind: "function" | "primitive" | "reference" | "generic" | "typeParam" | "union" | "anonymousStructure" | "literal" | "conditional" | "indexedAccess";
            typeName: string;
            typeNamespace: string;
        };
    }[];
    genStructure(structureName?: string, properties?: any[]): Structure;
    getEntities(): any[];
    computeStructure(): TypeAnnotation;
    saveStructure(): void;
    saveStructureNoInfer(entities?: any[]): void;
    removeStructure(structureName?: string): void;
    getEntityInfos(node: QueryFromExpression | QueryJoinExpression, set?: Set<unknown>): {
        namespace: string;
        name: string;
    }[];
    get entityInfos(): {
        namespace: string;
        name: string;
    }[];
    get dataSourceCompleteNames(): string[];
    get dataSourceSqlType(): any;
    get isSameSource(): boolean;
    getCompletionPropertyOfEntities(): {
        name: any;
        icon: any;
        children: {
            concept: string;
            name: string;
            entity: Entity;
            children: CompletionProperty[];
        }[];
    }[];
    getCompletionPropertyOfAggregateAsNames(): {
        name: string;
        icon: string;
        children: CompletionProperty[];
        expanded: boolean;
    };
    getCompletionPropertyOfGroupByAsNames(): {
        name: string;
        icon: string;
        children: CompletionProperty[];
        expanded: boolean;
    };
    /**
     * 获取当前内部使用到的变量
     */
    getContentVariable(): (Identifier | MemberExpression)[];
    initFieldSelectElement(node?: CallQueryComponent): void;
    inFromJoinPart(entityName: string): boolean;
    toNaturalTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
    toNaturalSQL(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
    toTextualNASL(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): string;
}
export default CallQueryComponent;
//# sourceMappingURL=CallQueryComponent__.d.ts.map