import { TranslatorState, TranslatorGenerator } from '@lcap/nasl-translator';
import { Range, GetCode } from './utils/quick-info';
import { ElementToVueOptions } from './ViewElement__';
import type Function from './Function__';
import * as types from './utils/types';
import LogicItem from './LogicItem__';
import type TypeAnnotation from './TypeAnnotation__';
import type Argument from './Argument__';
/**
 * 调用函数
 */
export declare class CallFunction extends LogicItem {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'CallFunction';
    /**
     * calleeNamespace
     */
    calleeNamespace: string;
    /**
     * calleeName
     */
    calleeName: string;
    /**
     * shortcut
     */
    shortcut?: boolean;
    /**
     * 类型参数
     */
    typeArguments?: Array<TypeAnnotation>;
    /**
     * 实际参数
     */
    arguments: Array<Argument>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<CallFunction>);
    static from(source: any, parentNode?: any, parentKey?: string): CallFunction;
    /**
     * 插入类型标注
     * @internal
     * @param typeAnnotationOptions 类型标注参数
     */
    _insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
    /**
     * 插入类型标注
     * @internal
     * @param typeAnnotation 已有的类型标注实例
     */
    _insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
    /**
     * 插入类型标注
     * @param typeAnnotationOptions 类型标注参数
     */
    insertTypeAnnotationAt(typeAnnotationOptions: Partial<TypeAnnotation>, index: number): TypeAnnotation;
    /**
     * 插入类型标注
     * @param typeAnnotation 已有的类型标注实例
     */
    insertTypeAnnotationAt(typeAnnotation: TypeAnnotation, index: number): TypeAnnotation;
    /**
     * 添加类型标注
     * @internal
     * @param typeAnnotationOptions 类型标注参数
     */
    _addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
    /**
     * 添加类型标注
     * @internal
     * @param typeAnnotation 已有的类型标注实例
     */
    _addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
    /**
     * 添加类型标注
     * @param typeAnnotationOptions 类型标注参数
     */
    addTypeAnnotation(typeAnnotationOptions: Partial<TypeAnnotation>): TypeAnnotation;
    /**
     * 添加类型标注
     * @param typeAnnotation 已有的类型标注实例
     */
    addTypeAnnotation(typeAnnotation: TypeAnnotation): TypeAnnotation;
    /**
     * 插入实际参数
     * @internal
     * @param argumentOptions 实际参数参数
     */
    _insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
    /**
     * 插入实际参数
     * @internal
     * @param argument 已有的实际参数实例
     */
    _insertArgumentAt(argument: Argument, index: number): Argument;
    /**
     * 插入实际参数
     * @param argumentOptions 实际参数参数
     */
    insertArgumentAt(argumentOptions: Partial<Argument>, index: number): Argument;
    /**
     * 插入实际参数
     * @param argument 已有的实际参数实例
     */
    insertArgumentAt(argument: Argument, index: number): Argument;
    /**
     * 添加实际参数
     * @internal
     * @param argumentOptions 实际参数参数
     */
    _addArgument(argumentOptions: Partial<Argument>): Argument;
    /**
     * 添加实际参数
     * @internal
     * @param argument 已有的实际参数实例
     */
    _addArgument(argument: Argument): Argument;
    /**
     * 添加实际参数
     * @param argumentOptions 实际参数参数
     */
    addArgument(argumentOptions: Partial<Argument>): Argument;
    /**
     * 添加实际参数
     * @param argument 已有的实际参数实例
     */
    addArgument(argument: Argument): Argument;
    /**
     * 删除类型标注
     * @param typeAnnotation 已有的类型标注实例
     */
    removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
    /**
     * 删除实际参数
     * @param argument 已有的实际参数实例
     */
    removeArgument(argument: Argument): void;
    name?: string;
    toVue(options?: ElementToVueOptions): string;
    toUI(state?: TranslatorState, hideDetails?: boolean): string;
    toJS(state?: TranslatorState): string;
    toBrief(): string;
    get calleeKey(): string;
    get isSqlFunction(): boolean;
    _setCallee(func: Function): void;
    setCallee(func: Function): void;
    detectArgs(obj?: any): void;
    setSqlCallee(func: any): void;
    /**
     * 获取数据查询组件内部，SQL 函数的使用位置
     * [
            "SELECT",
            "WHERE",
            "HAVING",
            "ORDER_BY",
            "GROUP_BY"
        ]
     */
    getScope(): string;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    toNaturalTS(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;
    getQuickInfoOffset(range: Range, getCode: GetCode): import("./utils/quick-info").QuickInfoData;
    get Argument(): Argument;
    get isDerivableList(): boolean;
    get isDerivableMap(): boolean;
    get isDerivableCollection(): boolean;
    get isLoopList(): boolean;
    get isLoopMap(): boolean;
    get isLoopCollection(): boolean;
    get derivableCollection(): types.LogicItemNode;
    get collection(): types.LogicItemNode;
    get keyOfCollection(): types.LogicItemNode;
    get itemOfCollection(): types.LogicItemNode;
}
export default CallFunction;
//# sourceMappingURL=CallFunction__.d.ts.map