import { TranslatorState, TranslatorGenerator } from '@lcap/nasl-translator';
import type ForEachStatement from './ForEachStatement__';
import type Assignment from './Assignment__';
import type BatchAssignment from './BatchAssignment__';
import type MatchCase from './MatchCase__';
import type AnonymousFunction from './AnonymousFunction__';
import type CallFunction from './CallFunction__';
import * as types from './utils/types';
import LogicItem from './LogicItem__';
import type Param from './Param__';
import type Return from './Return__';
import type Variable from './Variable__';
/**
 * 子逻辑
 */
export declare class SubLogic extends LogicItem {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'SubLogic';
    /**
     * 逻辑名称
     */
    name: string;
    /**
     * 输入参数列表
     */
    params: Array<Param>;
    /**
     * 输出参数列表
     */
    returns: Array<Return>;
    /**
     * 变量列表
     */
    variables: Array<Variable>;
    /**
     * 逻辑项列表
     */
    body: Array<types.LogicItemNode>;
    /**
     * 逻辑项列表
     */
    playground: Array<types.LogicItemNode>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<SubLogic>);
    static from(source: any, parentNode?: any, parentKey?: string): SubLogic;
    /**
     * 设置逻辑名称
     */
    setName(name: string): void;
    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;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _insertItemInBodyAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _insertItemInBodyAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    insertItemInBodyAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    insertItemInBodyAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _addItemInBody(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _addItemInBody(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    addItemInBody(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    addItemInBody(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _insertItemInPlaygroundAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _insertItemInPlaygroundAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    insertItemInPlaygroundAt(logicItemOptions: Partial<types.LogicItemNode>, index: number): types.LogicItemNode;
    /**
     * 插入逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    insertItemInPlaygroundAt(logicItem: types.LogicItemNode, index: number): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItemOptions 逻辑项参数
     */
    _addItemInPlayground(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @internal
     * @param logicItem 已有的逻辑项实例
     */
    _addItemInPlayground(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItemOptions 逻辑项参数
     */
    addItemInPlayground(logicItemOptions: Partial<types.LogicItemNode>): types.LogicItemNode;
    /**
     * 添加逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    addItemInPlayground(logicItem: types.LogicItemNode): types.LogicItemNode;
    /**
     * 删除输入参数
     * @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;
    /**
     * 删除逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    removeItemInBody(logicItem: types.LogicItemNode): void;
    /**
     * 删除逻辑项
     * @param logicItem 已有的逻辑项实例
     */
    removeItemInPlayground(logicItem: types.LogicItemNode): void;
    completionChildren: Array<SubLogic>;
    get __isVirtual(): boolean;
    getVarExistingNames(excludedList?: Array<Param | Variable | Return>): string[];
    toJSContent(code: string, state?: TranslatorState): string;
    toJS(state?: TranslatorState, type?: string): string;
    static getDefaultOptions(): Partial<{
        body: Array<any>;
        params: Array<any>;
        returns: Array<any>;
    }>;
    getRightCode(code: string, assignment: Assignment | BatchAssignment | CallFunction, rightNode: any): Generator<any, string, any>;
    handleForEachCode(code: string, forEachStatement: ForEachStatement): Generator<any, string, any>;
    handleCollectionCode(code: string, anonymousFunction: AnonymousFunction, callFunction: CallFunction): Generator<any, string, any>;
    handleReplaceCode(code: string, variable: string, replaceCode: string): string;
    handleMatchCaseCode(code: string, matchCase: MatchCase): Generator<any, string, any>;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>, prefix?: string, hideDefaultValue?: boolean): TranslatorGenerator;
    toEmbeddedTSInProcess(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>, prependCode?: string, noName?: boolean, prefix?: boolean): TranslatorGenerator;
    subLogics: SubLogic[];
    getSubLogics(): SubLogic[];
    get __name__(): string;
    get gatewayName(): string;
    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;
}
export default SubLogic;
//# sourceMappingURL=SubLogic__.d.ts.map