import { Engine } from '..';
import { ActionStatus } from '../constant';
export interface IBaseNodeProps {
    nodeConfig: BaseNode.NodeConfig;
    context: Record<string, any>;
    globalData: Record<string, unknown>;
}
export declare class BaseNode implements BaseNode.Base {
    readonly baseType: string;
    static nodeTypeName: string;
    /**
     * 节点的入边
     */
    incoming: BaseNode.IncomingConfig[];
    /**
     * 节点的出边
     */
    outgoing: BaseNode.OutgoingConfig[];
    /**
     * 节点的属性
     */
    properties?: Record<string, unknown>;
    nodeId: Engine.Key;
    type: string;
    /**
     * 节点的上下文，是调用流程时传入的上下文
     */
    context: Record<string, any>;
    /**
     * 节点的全局数据，是调用流程时传入的全局数据
     * 在计算表达式时，即基于全局数据进行计算
     */
    globalData: Record<string, unknown>;
    constructor({ nodeConfig, context, globalData }: IBaseNodeProps);
    /**
     * 节点的执行逻辑
     * @overridable 可以自定义节点重写此方法
     * @param param.executionId 流程执行记录 ID
     * @param param.actionId 此节点执行记录 ID
     * @param param.nodeId 节点 ID
     * @return 返回下一步的执行参数
     * 当不返回时，表示此节点执行成功，流程会继续执行下一步。
     * 当返回时，返回格式为
     */
    action(param?: Engine.ActionParam): Promise<BaseNode.ActionResult | undefined>;
    /**
     * 节点重新恢复执行的逻辑
     * @overridable 可以自定义节点重写此方法
     * @param params.executionId 流程执行记录 ID
     * @param params.actionId 此节点执行记录 ID
     * @param params.nodeId 节点 ID
     */
    onResume(params: Engine.ResumeParam): Promise<void>;
    /**
     * 判断该节点是否满足条件
     */
    private isPass;
    /**
     * 获取当前节点执行的下一个节点
     */
    private getOutgoing;
    /**
     * 节点的每一次执行都会生成一个唯一的 actionId
     */
    execute(params: Engine.ExecParam): Promise<Engine.NextActionParam>;
    resume(params: Engine.ExecResumeParam): Promise<undefined>;
}
export declare namespace BaseNode {
    interface Base {
        incoming: IncomingConfig[];
        outgoing: OutgoingConfig[];
        properties?: Record<string, unknown>;
        nodeId: Engine.Key;
        type: string;
        readonly baseType: string;
        execute(actionParam: Engine.ActionParam): Promise<Engine.NextActionParam>;
    }
    type IncomingConfig = {
        id: Engine.Key;
        source: string;
        properties?: Record<string, unknown>;
    };
    type OutgoingConfig = {
        id: Engine.Key;
        target: string;
        properties?: Record<string, unknown>;
        result?: string | boolean;
    };
    type NodeConfig = {
        id: Engine.Key;
        type: string;
        properties?: Record<string, unknown>;
        incoming: IncomingConfig[];
        outgoing: OutgoingConfig[];
    };
    type NodeConstructor = {
        new (config: {
            nodeConfig: NodeConfig;
            context: Record<string, any>;
            globalData: Record<string, unknown>;
        }): BaseNode;
    };
    type ActionResult = {
        status: ActionStatus;
        detail?: Record<string, unknown>;
    };
}
export default BaseNode;