import { Observable, Observer, Subject } from 'rxjs';
/**
 * Step operation execution manager
 *
 * Template type T: the event type. It's the return type of each operations
 * Template type DataType: context additional DataType
 * @experimental
 */
export declare class StepOperations<T, DataType extends Record<string, any>> {
    private operationContainers;
    private _state;
    _taskErrorHandler?: StepOperations.ErrorHandler;
    _currentExecutionEvents?: Subject<T>;
    _events: Subject<any>;
    get isCancelled(): boolean;
    get isCompleted(): boolean;
    get state(): StepOperations.State;
    get events(): Observable<any>;
    set taskErrorHandler(errorHandler: StepOperations.ErrorHandler | undefined);
    get operations(): StepOperations.Operation<T, DataType>[];
    constructor(operationContainers: StepOperations.OperationContainer<T, DataType>[]);
    static createSequentialContainers<EventType, DataType extends Record<string, any> = any>(operations: StepOperations.OperationType<EventType, DataType>[]): StepOperations.OperationContainer<EventType, DataType>[];
    static sequential<EventType, DataType extends Record<string, any> = any>(operations: StepOperations.OperationType<EventType, DataType>[]): StepOperations<EventType, DataType>;
    runEvents(): Observable<T>;
    /**
     * Reset as if operations were never executed.
     * Will call onReset callback for each Operation if defined.
     * @returns this
     */
    reset(): this;
    /**
     * Will retry from the last failed operation.
     * Call 'onRetry' callback for each Operation if definied.
     *
     * If all operations where successfully executed, it will do nothing.
     *
     * Call reset() first if you want to run operations again.
     */
    retry(): Observable<T>;
    /**
     * Execute operations
     * If it already running, do nothing
     *
     */
    run(): Observable<T>;
    /**
     * Cancel running operations
     */
    cancel(): void;
    /**
     * Transform this operation as an observable
     * Subscribe to observable to run operation
     * Unsubscribe to cancel operation
     *
     * Each time you call this method, a new observable is created
     */
    asObservable(): Observable<T>;
    private checkIsCancelled;
    private checkIsRunning;
    private _onTaskError;
    private _start;
    private onComplete;
    private onError;
}
export declare class StepOperationsError extends Error {
    code: string;
    constructor(code: string, msg: string);
    static cancel(): StepOperationsError;
    static unknown(msg: string): StepOperationsError;
}
export declare namespace StepOperationsError {
    enum Code {
        UNKNOWN_ERROR = "STEP_OPERATION_UNKNOWN_ERROR",
        STEP_OPERATION_CANCEL = "STEP_OPERATION_CANCEL"
    }
}
export declare namespace StepOperations {
    interface OperationContainer<T, DataType extends Record<string, any>> {
        index: number;
        done?: boolean;
        result?: T;
        error?: Error;
        operation: Operation<T, DataType>;
    }
    interface ErrorHandler {
        handle(err: Error, context: Context): void;
    }
    type OperationFct<T, DataType extends Record<string, any> = any> = (observer: Observer<T>, context: Context<DataType>) => Promise<any>;
    interface Operation<T, DataType extends Record<string, any> = any> {
        alias?: string;
        onRetry?: () => void;
        onReset?: () => void;
        perform(observer: Observer<T>, context: Context<DataType>): Promise<any>;
    }
    type OperationType<EventType, DataType extends Record<string, any> = any> = Operation<EventType, DataType> | OperationFct<EventType, DataType> | Observable<EventType>;
    interface Context<DataType extends Record<string, any> = any> {
        position: number;
        total: number;
        index: number;
        prevOperation?: StepOperations.OperationContainer<any, DataType>;
        data: DataType;
    }
    enum State {
        PENDING = "PENDING",
        RUNNING = "RUNNING",
        COMPLETED = "COMPLETED",
        CANCELED = "CANCELED",
        ERRORED = "ERRORED"
    }
}
export declare class IgnoreErrorStrategy {
}