import { BpmsEngine } from '../BpmsEngine';
import { BpmnDefinitionRepository } from './BpmnDefinitionRepository';
import { BpmnProcessInstance, BpmnProcessInstanceOptions } from './BpmnProcessInstance';
import { BpmnProcessRepository } from './BpmnProcessRepository';
import { IdExpression, FilterExpression, QueryOptions, ScalarOptions, QueryResult } from '../data/Repository';
import { BpmnEngineRuntimeState, BpmnEngineRuntimeApi, BpmnDefinition, BpmnExtensions, BpmnExtension, BpmnServices, BpmnService } from './definitions/bpmn-elements';
export declare type BpmnSource = string;
export interface BpmnEngineOptions {
    name: string;
    processRepository?: BpmnProcessRepository;
    bpmnDefinitionRepository?: BpmnDefinitionRepository;
}
export interface BpmnEngineRecoverOptions {
    filter?: FilterExpression;
    source?: string;
    resume?: boolean;
}
export interface BpmnEnginePersistOptions {
    filter?: FilterExpression;
    resume?: boolean;
}
export interface BpmsBpmnDefinition {
    id?: string;
    name: string;
    definitions: BpmnSource;
    systemId?: string;
    systemName?: string;
    category?: string;
    tags?: string[];
    version?: number;
    createdAt?: Date;
}
export interface BpmsProcess {
    id?: string;
    definitionId?: string;
    name: string;
    state: string;
    stopped: boolean;
    createdAt?: Date;
    persistedAt?: Date;
    data: any;
    isLoaded?: boolean;
}
export interface BpmnDefinitionLoadOptions {
    filter?: FilterExpression;
}
export declare class BpmnEngine {
    private loadedProcessRepository;
    private id;
    private name;
    private processRepository;
    private bpmnDefinitionRepository;
    private options;
    private bpmsEngine;
    constructor(options?: BpmnEngineOptions);
    constructor(bpmsEngine?: BpmsEngine, options?: BpmnEngineOptions);
    get Id(): string;
    get Name(): string;
    get BpmsEngine(): BpmsEngine | undefined;
    static createEngine(options?: BpmnEngineOptions): BpmnEngine;
    static createEngine(bpmsEngine?: BpmsEngine, options?: BpmnEngineOptions): BpmnEngine;
    private processExtensions;
    private processServices;
    registerProcessExtension(name: string, extension: BpmnExtension): this;
    removeProcessExtension(name: string): this;
    registerProcessService(name: string, service: BpmnService): this;
    removeProcessService(name: string): this;
    get ProcessExtensions(): BpmnExtensions;
    get ProcessServices(): BpmnServices;
    createDefinitions(entity: BpmsBpmnDefinition): Promise<BpmsBpmnDefinition>;
    updateDefinitions(entity: BpmsBpmnDefinition): Promise<BpmsBpmnDefinition>;
    countDefinitions(): Promise<number>;
    findDefinition<R extends BpmsBpmnDefinition = BpmsBpmnDefinition>(id: IdExpression): Promise<R | null>;
    findDefinition<R extends BpmsBpmnDefinition = BpmsBpmnDefinition>(filter: FilterExpression): Promise<R | null>;
    findProcess<R extends BpmsProcess = BpmsProcess>(id: IdExpression): Promise<R | null>;
    findProcess<R extends BpmsProcess = BpmsProcess>(filter: FilterExpression): Promise<R | null>;
    loadDefinitions<R extends BpmsBpmnDefinition = BpmsBpmnDefinition>(options: BpmnDefinitionLoadOptions): Promise<R[]>;
    loadDefinition(definition: {
        source: string;
        definitionId: string;
        definitionName: string;
        definitionVersion: number;
    }): Promise<BpmnDefinition>;
    removeDefinition(id: IdExpression): Promise<boolean>;
    listDefinitions<R extends BpmsBpmnDefinition>(filter?: FilterExpression): Promise<R[]>;
    clearDefinitions(): Promise<void>;
    listProcess<R extends BpmsProcess>(filter?: FilterExpression): Promise<R[]>;
    createProcess(options?: BpmnProcessInstanceOptions): Promise<BpmnProcessInstance>;
    loadedProcessCount(): Promise<number>;
    persistedDefinitionCount(): Promise<number>;
    persistedProcessCount(): Promise<number>;
    listLoadedProcess(filter?: FilterExpression): Promise<BpmnProcessInstance[]>;
    getProcess(id: IdExpression): Promise<BpmnProcessInstance | null>;
    getProcesses(filter: FilterExpression): Promise<BpmnProcessInstance[]>;
    recoverProcess(id: IdExpression, source?: string, resume?: boolean): Promise<BpmnProcessInstance | null>;
    /**
     * Recover process state from persistency source
     *
     * @param {BpmnEngineRecoverOptions} [options]
     * @returns {Promise<boolean>}
     * @memberof BpmnEngine
     */
    recoverProcesses(options?: BpmnEngineRecoverOptions): Promise<BpmnProcessInstance[]>;
    /**
     * Persist process
     *
     * @param {BpmnEnginePersistOptions} [options]
     * @returns {Promise<boolean>}
     * @memberof BpmnEngine
     */
    persistProcess(options?: BpmnEnginePersistOptions): Promise<boolean>;
    /**
     * Stop all processes
     *
     * @param {boolean} [persist=true] persist before stop all processes
     * @returns {Promise<void>}
     * @memberof BpmnEngine
     */
    stopProcesses(persist?: boolean, filter?: FilterExpression): Promise<void>;
    stopProcess(id: IdExpression, persist?: boolean): Promise<void>;
    getProcessState(id: IdExpression): Promise<BpmnEngineRuntimeState | null>;
    executeProcess(id: IdExpression, options?: BpmnProcessInstanceOptions): Promise<BpmnEngineRuntimeApi | null>;
    resumeProcess(id: IdExpression, options?: BpmnProcessInstanceOptions): Promise<BpmnEngineRuntimeApi | null>;
    queryDefinition<R>(options: QueryOptions): Promise<QueryResult<R>>;
    scalarDefinition(options: ScalarOptions): Promise<number>;
    queryProcess<R>(options: QueryOptions): Promise<QueryResult<R>>;
    scalarProcess(options: ScalarOptions): Promise<number>;
    static getDefaultExtensions(): BpmnExtensions;
    static getDefaultBpmnServices(bpmnEngine: BpmnEngine): BpmnServices;
}