import { BpmnEngine } from './BpmnEngine';
import { BpmnProcessModel } from './BpmnProcessRepository';
import { BpmnLogger, BpmnEnvironment, BpmnActivity, BpmnProcess, BpmnFlow, BpmnBroker, BpmnEngineRuntimeState, BpmnEngineRuntimeStateType, BpmnEngineRuntimeOptions, BpmnDefinition, BpmnEngineRuntimeApi, OnMessageCallback, BpmnEngineRuntimeExecution, BpmnErrorEventType, BpmnFlowEventType, BpmnActivityEventType } from './definitions/bpmn-elements';
export interface BpmnProcessInstanceOptions extends BpmnEngineRuntimeOptions {
    name?: string;
    id?: string;
    definitionId?: string;
    definitionName?: string;
    definitionVersion?: number;
    source?: string;
}
export declare type BpmnProcessExecuteOptions = BpmnProcessInstanceOptions;
export declare type BpmnProcessRecoverOptions = BpmnProcessInstanceOptions;
export declare type BpmnProcessResumeOptions = BpmnProcessInstanceOptions;
export declare class BpmnProcessInstance {
    private processRuntime;
    private bpmnEngine;
    private eventEmitter;
    private options?;
    private execution;
    private name;
    private id;
    private definitionId?;
    private definitionName?;
    private definitionVersion?;
    constructor(bpmnEngine: BpmnEngine, options?: BpmnProcessInstanceOptions);
    static getDefaultModdles(bpmnEngine: BpmnEngine): {
        nowjs: any;
    };
    get BpmnEngine(): BpmnEngine;
    get Id(): string;
    get Options(): {};
    get Source(): string | undefined;
    get DefinitionId(): string | undefined;
    get DefinitionName(): string | undefined;
    get DefinitionVersion(): number | undefined;
    get Logger(): BpmnLogger;
    get Name(): string;
    get Broker(): BpmnBroker;
    get State(): BpmnEngineRuntimeStateType;
    get Environment(): BpmnEnvironment;
    get Stopped(): boolean;
    get Execution(): BpmnEngineRuntimeExecution;
    execute(options?: BpmnProcessExecuteOptions): Promise<BpmnEngineRuntimeApi>;
    on<R>(eventName: BpmnErrorEventType, callback: (activity: BpmnActivity, processApi: BpmnProcess) => R): BpmnProcessInstance;
    on<R>(eventName: BpmnFlowEventType, callback: (activity: BpmnFlow, processApi: BpmnProcess) => R): BpmnProcessInstance;
    on<R>(eventName: BpmnActivityEventType, callback: (activity: BpmnActivity, processApi: BpmnProcess) => R): BpmnProcessInstance;
    once<R>(eventName: BpmnErrorEventType, callback: (activity: BpmnActivity, processApi: BpmnProcess) => R): BpmnProcessInstance;
    once<R>(eventName: BpmnFlowEventType, callback: (activity: BpmnFlow, processApi: BpmnProcess) => R): BpmnProcessInstance;
    once<R>(eventName: BpmnActivityEventType, callback: (activity: BpmnActivity, processApi: BpmnProcess) => R): BpmnProcessInstance;
    off<R>(eventName: BpmnErrorEventType, callback: (activity: BpmnActivity, processApi: BpmnProcess) => R): BpmnProcessInstance;
    off<R>(eventName: BpmnFlowEventType, callback: (activity: BpmnFlow, processApi: BpmnProcess) => R): BpmnProcessInstance;
    off<R>(eventName: BpmnActivityEventType, callback: (activity: BpmnActivity, processApi: BpmnProcess) => R): BpmnProcessInstance;
    onActivityWait(callback: (activity?: BpmnActivity, processApi?: BpmnProcess) => void): void;
    onEnd(callback: (payload?: any) => void): void;
    onError(callback: (error: Error) => void): void;
    /**
     * Stop execution
     *
     * @returns {Promise<void>}
     * @memberof BpmnProcess
     */
    stop(): Promise<void>;
    destroy(): boolean;
    listenerCount(type: string | symbol): number;
    getMaxListeners(): number;
    private emit;
    eventNames(): (string | symbol)[];
    private removeAllListeners;
    private removeListener;
    /**
     * Recover engine from state.
     *
     * @param {*} [savedState] engine state
     * @param {BpmnProcessRecoverOptions} [recoverOptions] optional object with options that will completely override the options passed to the engine at init
     * @returns {BpmnProcessInstance}
     * @memberof BpmnProcess
     */
    recover(savedState: BpmnProcessModel, recoverOptions?: BpmnProcessRecoverOptions): BpmnProcessInstance;
    /**
     * Resume execution function with previously saved engine state.
     *
     * @param {BpmnProcessResumeOptions} [options]
     * @returns {Promise<any>}
     * @memberof BpmnProcess
     */
    resume(options?: BpmnProcessResumeOptions): Promise<BpmnEngineRuntimeApi>;
    /**
     * Get all definitions
     *
     * @returns {Promise<BpmnDefinition>}
     * @memberof BpmnProcess
     */
    getDefinitions(): Promise<BpmnDefinition[]>;
    /**
     * Get definition by id, returns Promise
     *
     * @template R definition
     * @param {string} id
     * @returns {Promise<R>}
     * @memberof BpmnProcess
     */
    getDefinitionById(id: string): Promise<BpmnDefinition | null>;
    /**
     * Get state of a running execution. Listener events wait and start are recommended when saving state.
     *
     * @template S
     * @returns {Promise<S>}
     * @memberof BpmnProcess
     */
    getState(): Promise<BpmnEngineRuntimeState>;
    /**
     * wait for engine events, returns Promise
     *
     * @template T
     * @param {string} eventName event name
     * @returns {Promise<T>}
     * @memberof BpmnProcess
     */
    waitFor<T>(eventName: string, onMessage?: OnMessageCallback): Promise<T>;
}