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 MatchCase from './MatchCase__';
import TypeAnnotation from './TypeAnnotation__';
import type CallLogic from './CallLogic__';
import type BusinessComponent from './BusinessComponent__';
import type AnonymousFunction from './AnonymousFunction__';
import type Module from './Module__';
import type Connector from './Connector__';
import type View from './View__';
import type Frontend from './Frontend__';
import type ProcessElement from './ProcessElement__';
import type Process from './Process__';
import type CallFunction from './CallFunction__';
import type ProcessElementV2 from './ProcessElementV2__';
import type ProcessV2 from './ProcessV2__';
import type SubLogic from './SubLogic__';
import type BaseNode from '../common/BaseNode';
import type CallConnector from './CallConnector__';
import type FrontendType from './FrontendType__';
import type Directory from './Directory__';
export type ServiceType = {
    config: {
        serviceType: string;
    };
    url: {
        method: string;
        path: string;
    };
};
import { EventPayload } from '../common/types';
import * as types from './utils/types';
import Annotatable from './Annotatable__';
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__';
import type SharedScope from './SharedScope__';
/**
 * 逻辑
 */
export declare class Logic extends Annotatable {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'Logic' | 'AuthLogic' | 'AuthLogicForCallInterface' | 'BusinessLogic' | 'ConnectorLogic';
    /**
     * 逻辑名称
     */
    name: string;
    /**
     * 逻辑标题
     */
    title?: string;
    /**
     * 逻辑描述
     */
    description?: string;
    /**
     * 触发方式
     */
    triggerType?: string;
    /**
     * 定时任务表达式
     */
    cron?: string;
    /**
     * 是否可覆写
     */
    overridable?: boolean;
    /**
     * 事务
     */
    transactional?: Transactional;
    /**
     * 类型参数列表
     */
    typeParams?: Array<TypeParam>;
    /**
     * 输入参数列表
     */
    params: Array<Param>;
    /**
     * 输出参数列表
     */
    returns: Array<Return>;
    /**
     * 变量列表
     */
    variables: Array<Variable>;
    /**
     * 逻辑项列表
     */
    body: Array<types.LogicItemNode>;
    /**
     * 逻辑项列表
     */
    playground: Array<types.LogicItemNode>;
    /**
     * 共享范围
     */
    sharedScope?: SharedScope;
    __LSTypeAnnotation?: TypeAnnotation;
    /**
     * 是否同步
     */
    sync?: boolean;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<Logic>);
    static from(source: any, parentNode?: any, parentKey?: string): Logic;
    /**
     * 设置逻辑名称
     */
    setName(name: string): void;
    /**
     * 设置逻辑标题
     */
    setTitle(title: string): void;
    /**
     * 设置逻辑描述
     */
    setDescription(description: string): void;
    /**
     * 设置触发方式
     */
    setTriggerType(triggerType: string): void;
    /**
     * 设置定时任务表达式
     */
    setCron(cron: string): void;
    /**
     * 设置是否可覆写
     */
    setOverridable(overridable: boolean): void;
    /**
     * 设置事务
     */
    setTransactional(transactional: Transactional): void;
    /**
     * 设置共享范围
     */
    setSharedScope(sharedScope: SharedScope): void;
    /**
     * 设置是否同步
     */
    setSync(sync: boolean): 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;
    /**
     * 祖先 Connector
     */
    get connector(): Connector;
    /**
     * 祖先 View
     */
    get view(): View;
    /**
     * 祖先 Frontend
     */
    get frontend(): Frontend;
    /**
     * 祖先 FrontendType
     */
    get frontendType(): FrontendType;
    /**
     * 祖先 ProcessElement
     */
    get processElement(): ProcessElement;
    /**
     * 祖先 Process
     */
    get process(): Process;
    get processElementV2(): ProcessElementV2;
    /**
     * 祖先 ProcessV2
     */
    get processV2(): ProcessV2;
    get __isVirtual(): boolean;
    get calleewholeKey(): string;
    get completeName(): string;
    get directory(): Directory;
    setCronAndTriggerType(cron: string, triggerType: string): void;
    static createProtoTypeOnly(source: Partial<Logic>): Logic;
    /**
     * 创建的时候 打开事务 通过开关设置数据库事务
     */
    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;
        };
    };
    toMockService(): any;
    toService(call?: CallLogic | CallConnector): {
        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;
    get tsName(): string;
    toEmbeddedDeclarationTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>, prefix?: string): TranslatorGenerator;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>, prefix?: string, hideDefaultValue?: boolean): 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>, 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>;
    handleCollectionCode(code: string, anonymousFunction: AnonymousFunction, callFunction: CallFunction): 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<Logic>;
    toEmbeddedDeclarationTSFile(): Embedded.DeclarationTSFileResult;
    static getDefaultOptions(): Partial<{
        body: Array<any>;
        params: Array<any>;
        returns: Array<any>;
    }>;
    setTransactionEnabled(flag: boolean): void;
    fake: boolean;
    getPath: () => string;
    delete(): void;
    asyncDelete(): Promise<void>;
    deleteExpectInterface(): void;
    haveError: boolean;
    isSmpty: boolean;
    get exportInterfaces(): types.AbstractInterfaceNode[];
    get exportInterface(): types.AbstractInterfaceNode;
    get pathName(): string;
    getEventLogicName(type?: string): string;
    virtualParams: Array<Param>;
    get getLogicBelongTo(): string;
    static checkLogicReturnTypeHasError(logic: Logic): boolean;
    checkLogicReturnTypeHasError(): boolean;
    get integration(): import("./Integration__").Integration;
    get likeComponent(): View | BusinessComponent;
    subLogics: Array<SubLogic>;
    getSubLogics(): SubLogic[];
    existingSubLogic: Set<string>;
    collectExistSubLogic(): SubLogic[];
    getSubLogicExistingNames(excludedList?: Array<SubLogic>): string[];
    getSubLogicUniqueName(name?: string, excludedNames?: Array<string>): string;
    /**
     * 完成的泛型参数
     * 先指支持依赖库的泛型参数
     * 所以别的都输出 空数组，让别的走旧逻辑
     */
    get completeTypeParams(): TypeParam[];
    isSSE(): boolean;
    openSharedScope(): void;
    closeSharedScope(): void;
}
export default Logic;
//# sourceMappingURL=Logic__.d.ts.map