import type { Embedded } from '@lcap/nasl-types';
import { TranslatorGenerator } from '@lcap/nasl-translator';
import type Logic from './Logic__';
import type Module from './Module__';
import type SubLogic from './SubLogic__';
import { EventPayload } from '../common/types';
import BaseNode from '../common/BaseNode';
import type BindEvent from './BindEvent__';
import type Param from './Param__';
import type Return from './Return__';
import type Constant from './Constant__';
import type ProcessElement from './ProcessElement__';
/**
 * 流程
 */
export declare class Process extends BaseNode {
    /** 类名 */
    static readonly ConceptName: string;
    /**
     * 是否为抽象类
     * 抽象类不能产生 concept: string
     */
    static isAbstract: boolean;
    /** 继承链 */
    static readonly inheritanceChain: string[];
    /**
     * 产品概念
     */
    readonly concept: 'Process';
    /**
     * 流程名称
     */
    name: string;
    /**
     * 流程标题
     */
    title: string;
    /**
     * 流程描述
     */
    description?: string;
    /**
     * 元素绑定事件列表
     */
    bindEvents: Array<BindEvent>;
    /**
     * 输入参数列表
     */
    params: Array<Param>;
    /**
     * 输出参数列表
     */
    returns: Array<Return>;
    /**
     * 常量列表
     */
    constants: Array<Constant>;
    /**
     * 流程元素列表
     */
    elements: Array<ProcessElement>;
    /**
     * @param source 需要合并的部分参数
     */
    constructor(source?: Partial<Process>);
    static from(source: any, parentNode?: any, parentKey?: string): Process;
    /**
     * 设置流程名称
     */
    setName(name: string): void;
    /**
     * 设置流程标题
     */
    setTitle(title: string): void;
    /**
     * 设置流程描述
     */
    setDescription(description: string): void;
    getBindEventExistingNames(excludedList?: Array<BindEvent>): string[];
    getBindEventUniqueName(name?: string): string;
    /**
     * 插入元素绑定事件
     * @internal
     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
     */
    _insertBindEventAt(name: string, index: number): BindEvent;
    /**
     * 插入元素绑定事件
     * @internal
     * @param bindEventOptions 元素绑定事件参数
     */
    _insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
    /**
     * 插入元素绑定事件
     * @internal
     * @param bindEvent 已有的元素绑定事件实例
     */
    _insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
    /**
     * 插入元素绑定事件
     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
     */
    insertBindEventAt(name: string, index: number): BindEvent;
    /**
     * 插入元素绑定事件
     * @param bindEventOptions 元素绑定事件参数
     */
    insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
    /**
     * 插入元素绑定事件
     * @param bindEvent 已有的元素绑定事件实例
     */
    insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
    /**
     * 添加元素绑定事件
     * @internal
     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
     */
    _addBindEvent(name?: string): BindEvent;
    /**
     * 添加元素绑定事件
     * @internal
     * @param bindEventOptions 元素绑定事件参数
     */
    _addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
    /**
     * 添加元素绑定事件
     * @internal
     * @param bindEvent 已有的元素绑定事件实例
     */
    _addBindEvent(bindEvent: BindEvent): BindEvent;
    /**
     * 添加元素绑定事件
     * @internal
     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
     */
    addBindEvent(name?: string): BindEvent;
    /**
     * 添加元素绑定事件
     * @param bindEventOptions 元素绑定事件参数
     */
    addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
    /**
     * 添加元素绑定事件
     * @param bindEvent 已有的元素绑定事件实例
     */
    addBindEvent(bindEvent: BindEvent): BindEvent;
    getParamExistingNames(excludedList?: Array<Param>): string[];
    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;
    getReturnExistingNames(excludedList?: Array<Return>): string[];
    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;
    getConstantExistingNames(excludedList?: Array<Constant>): string[];
    getConstantUniqueName(name?: string): string;
    /**
     * 插入常量
     * @internal
     * @param name 常量名称，如果不填会自动生成一个唯一名称
     */
    _insertConstantAt(name: string, index: number): Constant;
    /**
     * 插入常量
     * @internal
     * @param constantOptions 常量参数
     */
    _insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
    /**
     * 插入常量
     * @internal
     * @param constant 已有的常量实例
     */
    _insertConstantAt(constant: Constant, index: number): Constant;
    /**
     * 插入常量
     * @param name 常量名称，如果不填会自动生成一个唯一名称
     */
    insertConstantAt(name: string, index: number): Constant;
    /**
     * 插入常量
     * @param constantOptions 常量参数
     */
    insertConstantAt(constantOptions: Partial<Constant>, index: number): Constant;
    /**
     * 插入常量
     * @param constant 已有的常量实例
     */
    insertConstantAt(constant: Constant, index: number): Constant;
    /**
     * 添加常量
     * @internal
     * @param name 常量名称，如果不填会自动生成一个唯一名称
     */
    _addConstant(name?: string): Constant;
    /**
     * 添加常量
     * @internal
     * @param constantOptions 常量参数
     */
    _addConstant(constantOptions: Partial<Constant>): Constant;
    /**
     * 添加常量
     * @internal
     * @param constant 已有的常量实例
     */
    _addConstant(constant: Constant): Constant;
    /**
     * 添加常量
     * @internal
     * @param name 常量名称，如果不填会自动生成一个唯一名称
     */
    addConstant(name?: string): Constant;
    /**
     * 添加常量
     * @param constantOptions 常量参数
     */
    addConstant(constantOptions: Partial<Constant>): Constant;
    /**
     * 添加常量
     * @param constant 已有的常量实例
     */
    addConstant(constant: Constant): Constant;
    getElementExistingNames(excludedList?: Array<ProcessElement>): string[];
    getElementUniqueName(name?: string): string;
    /**
     * 插入流程元素
     * @internal
     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
     */
    _insertElementAt(name: string, index: number): ProcessElement;
    /**
     * 插入流程元素
     * @internal
     * @param elementOptions 流程元素参数
     */
    _insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
    /**
     * 插入流程元素
     * @internal
     * @param element 已有的流程元素实例
     */
    _insertElementAt(element: ProcessElement, index: number): ProcessElement;
    /**
     * 插入流程元素
     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
     */
    insertElementAt(name: string, index: number): ProcessElement;
    /**
     * 插入流程元素
     * @param elementOptions 流程元素参数
     */
    insertElementAt(elementOptions: Partial<ProcessElement>, index: number): ProcessElement;
    /**
     * 插入流程元素
     * @param element 已有的流程元素实例
     */
    insertElementAt(element: ProcessElement, index: number): ProcessElement;
    /**
     * 添加流程元素
     * @internal
     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
     */
    _addElement(name?: string): ProcessElement;
    /**
     * 添加流程元素
     * @internal
     * @param elementOptions 流程元素参数
     */
    _addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
    /**
     * 添加流程元素
     * @internal
     * @param element 已有的流程元素实例
     */
    _addElement(element: ProcessElement): ProcessElement;
    /**
     * 添加流程元素
     * @internal
     * @param name 流程元素名称，如果不填会自动生成一个唯一名称
     */
    addElement(name?: string): ProcessElement;
    /**
     * 添加流程元素
     * @param elementOptions 流程元素参数
     */
    addElement(elementOptions: Partial<ProcessElement>): ProcessElement;
    /**
     * 添加流程元素
     * @param element 已有的流程元素实例
     */
    addElement(element: ProcessElement): ProcessElement;
    /**
     * 删除元素绑定事件
     * @param name 元素绑定事件名称
     */
    removeBindEvent(name: string): void;
    /**
     * 删除元素绑定事件
     * @param bindEvent 已有的元素绑定事件实例
     */
    removeBindEvent(bindEvent: BindEvent): 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 常量名称
     */
    removeConstant(name: string): void;
    /**
     * 删除常量
     * @param constant 已有的常量实例
     */
    removeConstant(constant: Constant): void;
    /**
     * 删除流程元素
     * @param name 流程元素名称
     */
    removeElement(name: string): void;
    /**
     * 删除流程元素
     * @param element 已有的流程元素实例
     */
    removeElement(element: ProcessElement): void;
    /**
     * 当前节点是否是虚拟的
     */
    __isVirtual?: Boolean;
    /**
     * 祖先 Module
     */
    get module(): Module;
    onChange($event?: EventPayload): void;
    _removeElement(element: ProcessElement): {
        propertyName: string;
        index: number;
    };
    getVarExistingNames(excludedList?: Array<Param | Return | Constant | ProcessElement>): string[];
    getNamespace(ns?: string): string;
    getEmbeddedFilePath(name?: string): string;
    genExclusiveGatewayLogic(elem: ProcessElement): Logic;
    get logics(): Logic[];
    /**
     * 获取当前逻辑下所有elements上bindEvents下的logic
     */
    elementLogicRoot: any[];
    getElementLogicRoot(): void;
    toUserTaskPropertyGetterTS(userTask: ProcessElement): string;
    toEmbeddedTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    toEmbeddedDeclarationTS(state?: import("@lcap/nasl-types/out/translator").TranslatorState<import("@lcap/nasl-types/out/concepts").BaseNode>): TranslatorGenerator;
    toEmbeddedTSFile(): Embedded.TSFileGenerator<Process>;
    toEmbeddedDeclarationTSFile(): Embedded.DeclarationTSFileResult;
    static getDefaultOptions(): {
        constants: {
            concept: string;
            name: string;
            typeAnnotation: {
                concept: string;
                typeKind: string;
                typeNamespace: string;
                typeName: string;
            };
        }[];
        elements: ({
            concept: string;
            name: string;
            type: string;
            title: string;
            bounds: {
                concept: string;
                x: number;
                y: number;
            };
            sourceRef?: undefined;
            targetRef?: undefined;
            waypoints?: undefined;
        } | {
            bounds: {
                concept: string;
                x: number;
                y: number;
            };
            bindAttrs: {
                concept: string;
                name: string;
                assignee: {
                    concept: string;
                };
            }[];
            constants: {
                concept: string;
                name: string;
                typeAnnotation: {
                    concept: string;
                    typeKind: string;
                    typeNamespace: string;
                    typeName: string;
                };
            }[];
            concept: string;
            name: string;
            type: string;
            title: string;
            sourceRef?: undefined;
            targetRef?: undefined;
            waypoints?: undefined;
        } | {
            bounds: {
                concept: string;
                x: number;
                y: number;
            };
            bindAttrs: {
                concept: string;
                name: string;
                assignee: {
                    concept: string;
                };
            }[];
            constants: {
                concept: string;
                name: string;
                typeAnnotation: {
                    concept: string;
                    typeKind: string;
                    typeNamespace: string;
                    typeName: string;
                };
            }[];
            concept: string;
            name: string;
            type: string;
            title: string;
            returns: {
                concept: string;
                description: string;
                name: string;
                typeAnnotation: {
                    concept: string;
                    typeKind: string;
                    typeNamespace: string;
                    typeName: string;
                };
            }[];
            sourceRef?: undefined;
            targetRef?: undefined;
            waypoints?: undefined;
        } | {
            concept: string;
            name: string;
            type: string;
            sourceRef: string;
            targetRef: string;
            waypoints: {
                x: number;
                y: number;
            }[];
            title?: undefined;
            bounds?: undefined;
        })[];
    };
    subLogics: Array<SubLogic>;
    getSubLogics(): void;
    get includeSpreadCallLogic(): boolean;
    get includeTypeArgs(): boolean;
}
export default Process;
export declare const HasLogicProcessElement: Set<string>;
//# sourceMappingURL=Process__.d.ts.map