import type { Embedded } from '@lcap/nasl-types';
import { TranslatorState, TranslatorGenerator } from '@lcap/nasl-translator';
import type ForEachStatement from './ForEachStatement__';
import type Assignment from './Assignment__';
import type BatchAssignment from './BatchAssignment__';
import type CallFunction from './CallFunction__';
import type MatchCase from './MatchCase__';
import Logic from './Logic__';
import type Module from './Module__';
import type View from './View__';
import type Frontend from './Frontend__';
import type ProcessElement from './ProcessElement__';
import type Process from './Process__';
import { EventPayload } from '../common/types';
import * as types from './utils/types';
import BaseNode from '../common/BaseNode';
import type Transactional from './Transactional__';
import type TypeParam from './TypeParam__';
import type Param from './Param__';
import type Return from './Return__';
import type Variable from './Variable__';
import type LogicItem from './LogicItem__';
/**
 * 覆写逻辑
 */
export declare class OverriddenLogic extends BaseNode {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'OverriddenLogic';
    /**
     * 覆写的模块
     */
    overriddenModule: string;
    /**
     * 覆写逻辑名称
     */
    name: string;
    /**
     * 覆写逻辑描述
     */
    description: string;
    /**
     * 触发方式
     */
    triggerType?: string;
    /**
     * 定时任务表达式
     */
    cron?: string;
    /**
     * 事务
     */
    transactional?: Transactional;
    /**
     * 类型参数列表
     */
    typeParams?: Array<TypeParam>;
    /**
     * 输入参数列表
     */
    params: Array<Param>;
    /**
     * 输出参数列表
     */
    returns: Array<Return>;
    /**
     * 变量列表
     */
    variables: Array<Variable>;
    /**
     * 逻辑项列表
     */
    body: Array<types.LogicItemNode>;
    /**
     * 逻辑项列表
     */
    playground: Array<types.LogicItemNode>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<OverriddenLogic>);
    static from(source: any, parentNode?: any, parentKey?: string): OverriddenLogic;
    /**
     * 设置覆写的模块
     */
    setOverriddenModule(overriddenModule: string): void;
    /**
     * 设置覆写逻辑名称
     */
    setName(name: string): void;
    /**
     * 设置覆写逻辑描述
     */
    setDescription(description: string): void;
    /**
     * 设置触发方式
     */
    setTriggerType(triggerType: string): void;
    /**
     * 设置定时任务表达式
     */
    setCron(cron: string): void;
    /**
     * 设置事务
     */
    setTransactional(transactional: Transactional): void;
    getTypeParamExistingNames(excludedList?: Array<TypeParam>): string[];
    getTypeParamUniqueName(name?: string): string;
    /**
     * 插入类型参数
     * @internal
     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
     */
    _insertTypeParamAt(name: string, index: number): TypeParam;
    /**
     * 插入类型参数
     * @internal
     * @param typeParamOptions 类型参数参数
     */
    _insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
    /**
     * 插入类型参数
     * @internal
     * @param typeParam 已有的类型参数实例
     */
    _insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
    /**
     * 插入类型参数
     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
     */
    insertTypeParamAt(name: string, index: number): TypeParam;
    /**
     * 插入类型参数
     * @param typeParamOptions 类型参数参数
     */
    insertTypeParamAt(typeParamOptions: Partial<TypeParam>, index: number): TypeParam;
    /**
     * 插入类型参数
     * @param typeParam 已有的类型参数实例
     */
    insertTypeParamAt(typeParam: TypeParam, index: number): TypeParam;
    /**
     * 添加类型参数
     * @internal
     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
     */
    _addTypeParam(name?: string): TypeParam;
    /**
     * 添加类型参数
     * @internal
     * @param typeParamOptions 类型参数参数
     */
    _addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
    /**
     * 添加类型参数
     * @internal
     * @param typeParam 已有的类型参数实例
     */
    _addTypeParam(typeParam: TypeParam): TypeParam;
    /**
     * 添加类型参数
     * @internal
     * @param name 类型参数名称，如果不填会自动生成一个唯一名称
     */
    addTypeParam(name?: string): TypeParam;
    /**
     * 添加类型参数
     * @param typeParamOptions 类型参数参数
     */
    addTypeParam(typeParamOptions: Partial<TypeParam>): TypeParam;
    /**
     * 添加类型参数
     * @param typeParam 已有的类型参数实例
     */
    addTypeParam(typeParam: TypeParam): TypeParam;
    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 类型参数名称
     */
    removeTypeParam(name: string): void;
    /**
     * 删除类型参数
     * @param typeParam 已有的类型参数实例
     */
    removeTypeParam(typeParam: TypeParam): void;
    /**
     * 删除输入参数
     * @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;
    /**
     * 祖先 Module
     */
    get module(): Module;
    /**
     * 祖先 View
     */
    get view(): View;
    /**
     * 祖先 Frontend
     */
    get frontend(): Frontend;
    /**
     * 祖先 ProcessElement
     */
    get processElement(): ProcessElement;
    /**
     * 祖先 Process
     */
    get process(): Process;
    get calleewholeKey(): string;
    setCronAndTriggerType(cron: string, triggerType: string): void;
    /**
     * 创建的时候 打开事务 通过开关设置数据库事务
     */
    openTransactional(flag: boolean): void;
    findLogicItemByConcept(concept: string): LogicItem;
    onChange($event?: EventPayload): void;
    getVarExistingNames(excludedList?: Array<Param | Return | Variable>): any[];
    toJSContent(code: string, state?: TranslatorState): string;
    toJS(state?: TranslatorState, type?: string): string;
    toProcessService(): {
        config: {
            serviceType: string;
        };
        url: {
            method: string;
            path: string;
        };
    };
    toService(): {
        config: {
            serviceType: string;
        };
        url: {
            method: string;
            path: string;
        };
    };
    toEmbeddedTSInProcess(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>, prependCode?: string, noName?: boolean, prefix?: boolean): TranslatorGenerator;
    toEmbeddedTSNoExport(state?: TranslatorState): string;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>, prefix?: string): TranslatorGenerator;
    toEmbeddedDeclarationTSFile(): Embedded.DeclarationTSFileResult;
    getTokenKeyWithNamespace(): 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>, prefix?: string, logicName?: string, currentNode?: BaseNode): string;
    getRightCode(code: string, assignment: Assignment | BatchAssignment | CallFunction, rightNode: any): Generator<any, string, any>;
    handleReplaceCode(code: string, variable: string, replaceCode: string): string;
    handleForEachCode(code: string, forEachStatement: ForEachStatement): Generator<any, string, any>;
    handleMatchCaseCode(code: string, matchCase: MatchCase): Generator<any, string, any>;
    getNamespace(): string;
    getTsNamespace(): string;
    /**
     * 生成宿主语言的文件路径
     * @param name 一般不用传，用于 rename
     */
    getEmbeddedFilePath(name?: string): string;
    toEmbeddedTSFile(): Embedded.TSFileGenerator<OverriddenLogic>;
    static getDefaultOptions(): {
        body: {
            concept: string;
            label: string;
            kind: string;
            type: string;
        }[];
    };
    setTransactionEnabled(flag: boolean): void;
    fake: boolean;
    getPath: () => string;
    delete(): void;
    haveError: boolean;
    isSmpty: boolean;
    get pathName(): string;
    getEventLogicName(type?: string): string;
    virtualParams: Array<Param>;
    get getLogicBelongTo(): string;
    static checkLogicReturnTypeHasError(logic: Logic): boolean;
    get getIsEmptyLogic(): boolean;
    getOverriddenDepLogic(): Logic | null;
}
export default OverriddenLogic;
//# sourceMappingURL=OverriddenLogic__.d.ts.map