import { MiddlewareInterface, PipelineInterface } from "./interfaces";
/**
 * Shared pipeline code.
 */
export declare abstract class BasePipeline<TContext, TResult, TReserved> implements PipelineInterface<TContext, TResult, TReserved> {
    /**
     * Internally stored array of Middleware functions.
     */
    protected readonly _middleware: MiddlewareInterface<TContext, TResult>[];
    /**
     * @constructor
     * @param middleware
     */
    protected constructor(middleware: MiddlewareInterface<TContext, TResult>[]);
    /**
     * Internally stored array of Middleware functions.
     */
    readonly middleware: MiddlewareInterface<TContext, TResult>[];
    /**
     * Pipeline has no middleware flag.
     */
    readonly isEmpty: boolean;
    /**
     * Array of Middleware functions stored inside Pipeline.
     */
    toArray(): MiddlewareInterface<TContext, TResult>[];
    /**
     * Pointer interface for creating an empty IntermediatePipeline.
     */
    empty(): PipelineInterface<unknown, unknown, unknown>;
    /**
     * Create new Pipeline containing Middleware functions of both current Pipeline and the Pipeline passed as an
     * argument.
     * @abstract
     * @param o
     */
    abstract concat<TNewResult>(o: PipelineInterface<TResult, TNewResult, TReserved>): any;
    /**
     * Create a new Pipeline with Middleware provided as an argument appended to the end of the Middleware list.
     * @abstract
     * @param middleware
     */
    abstract pipe<TNewResult>(middleware: MiddlewareInterface<TResult, TNewResult>): any;
    /**
     * Sequentially call middleware functions stored inside IntermediatePipeline starting with context provided as an
     * argument.
     * @abstract
     * @param ctx
     */
    abstract process(ctx: TReserved): any;
}