import { MiddlewareContextInterface, MiddlewareLikeType, PipelineInterface } from './interfaces';
/**
 * Shared pipeline code.
 *
 * @implements IterableIterator
 * @implements PipelineInterface
 */
export declare abstract class BasePipeline<TIntermediate = {}, TContext = MiddlewareContextInterface<TIntermediate>> implements PipelineInterface<TIntermediate, TContext> {
    /**
     * Internally stored array of middleware.
     *
     * @type MiddlewareLikeType[]
     * @protected
     */
    protected readonly _middleware: Array<MiddlewareLikeType<TContext>>;
    /**
     * Current iteration index.
     *
     * @type {number}
     * @protected
     */
    protected _index: number;
    /**
     * Iterator done flag.
     *
     * @type {boolean}
     * @protected
     */
    protected _done: boolean;
    /**
     * @constructor
     * @param {MiddlewareLikeType[]} middleware
     */
    protected constructor(middleware: Array<MiddlewareLikeType<TContext>>);
    /**
     * Transform Pipeline to array of middleware.
     *
     * @returns {MiddlewareLikeType[]}
     */
    toArray(): Array<MiddlewareLikeType<TContext>>;
    /**
     * Concat current middleware with argument pipeline of the same generic type.
     *
     * @param {PipelineInterface<TIntermediate>} x
     * @returns {PipelineInterface<TIntermediate>}
     */
    concat(x: PipelineInterface<TIntermediate, TContext>): PipelineInterface<TIntermediate, TContext>;
    /**
     * Create a pipeline that has no middleware.
     *
     * @returns {Pipeline<TIntermediate>}
     */
    empty(): PipelineInterface<TIntermediate>;
    /**
     * Sequentially process middleware internally stored in the pipeline.
     *
     * If the middleware currently being executed returns a Promise, the Promise will be resolved before moving on to
     * the next middleware. Pipeline does not block the event loop. To avoid resolving the Promise, assign it to a key
     * of the middleware context and return void.
     *
     * @param {TContext} ctx
     * @returns {Promise<any>}
     */
    abstract process(ctx: TContext): any;
    /**
     * @returns {IterableIterator<MiddlewareLikeType>}
     */
    [Symbol.iterator](): IterableIterator<MiddlewareLikeType<TContext>>;
    /**
     * @param {MiddlewareLikeType<TContext>} value
     * @returns {IteratorResult<MiddlewareLikeType<TContext>>}
     */
    next(value?: MiddlewareLikeType<TContext>): IteratorResult<MiddlewareLikeType<TContext>>;
    /**
     * Getter for _isEmpty.
     *
     * @returns {boolean}
     */
    readonly isEmpty: boolean;
    /**
     * Getter for _done.
     *
     * @returns {boolean}
     */
    readonly done: boolean;
    /**
     * Getter for _middleware.
     *
     * @returns {Array<MiddlewareLikeType<TContext>>}
     */
    readonly middleware: Array<MiddlewareLikeType<TContext>>;
}