import { BasePipeline } from "./base-pipeline";
import { MiddlewareInterface } from "./interfaces";
/**
 * Pipeline is an inverted Monoid that stores an array of middleware functions to be applied to data passed as
 * pipeline.process() argument.
 *
 * **NOTE**: Pipeline creates a shallow copy of the context argument before passing it to the first middleware.
 */
export declare class Pipeline<TContext, TResult, TReserved> extends BasePipeline<TContext, TResult, TReserved> {
    /**
     * Pointer interface for lifting given middleware function to a Pipeline.
     * @param middleware - n Middleware functions.
     */
    static of<TContext, TResult, TReserved = TContext>(middleware: MiddlewareInterface<TContext, TResult>): Pipeline<TContext, TResult extends Promise<infer U> ? U : TResult, TReserved>;
    /**
     * Pointer interface for creating a Pipeline from array of Middleware.
     * @param middleware - Array of Middleware functions.
     */
    static from<TContext, TResult, TReserved = TContext>(middleware: MiddlewareInterface<any, any>[]): Pipeline<TContext, TResult, TReserved>;
    /**
     * Pointer interface for creating an empty Pipeline.
     */
    static empty<TContext, TResult, TReserved>(): Pipeline<TContext, TResult, TReserved>;
    /**
     * Create new Pipeline containing Middleware functions of both current Pipeline and the Pipeline passed as an
     * argument.
     * @param o
     */
    concat<TNewResult>(o: Pipeline<TResult, TNewResult, TReserved>): Pipeline<TResult, TNewResult extends Promise<infer U> ? U : TNewResult, TReserved>;
    /**
     * Create a new Pipeline with Middleware provided as an argument appended to the end of the Middleware list.
     * @param middleware
     */
    pipe<TNewResult>(middleware: MiddlewareInterface<TResult, TNewResult>): Pipeline<TResult, TNewResult extends Promise<infer U> ? U : TNewResult, TReserved>;
    /**
     * Sequentially call middleware functions stored inside Pipeline starting with context provided as an
     * argument.
     *
     * Values returned from middleware functions will be passed to the next middleware as an argument.
     *
     * If middleware that is currently being processed returns a Promise, it will be resolved before being passed to
     * the next middleware.
     *
     * Returns Promise of contents of the transformed context. If error occurs during execution, it can be caught with
     * returned Promise `.catch`.
     *
     * @param ctx
     */
    process(ctx?: TReserved): Promise<TResult>;
}