import { IParallelChainState, IScheduledParallelChainState, IParallelChainEnvironment } from "./parallel-chain-state";
import { IParallelOperation, IDefaultInitializedParallelOptions } from "../";
import { IParallelStream } from "../stream/parallel-stream";
import { ParallelEnvironmentDefinition } from "../parallel-environment-definition";
/**
 * The state of a parallel chain if additional operations should be performed on an already scheduled parallel chain.
 *
 * The state needs to wait for the previous parallel job to complete and then take that result to continue the additional
 * computations.
 *
 * @param TPrevious Type of the array elements of the dependent stream
 * @param TElement Type of the array elements of the resulting array
 */
export declare class DependentParallelChainState<TPrevious, TElement> implements IParallelChainState<TElement> {
    private previousStream;
    private options;
    private environment;
    private operations;
    /**
     * Creates a new dependent stream
     * @param previousStream the stream upon which the new stream depends on
     * @param options the options used by this parallel job
     * @param environment the environment used by the job
     * @param operations the operations to performed when the previous stream has completed
     */
    constructor(previousStream: IParallelStream<TPrevious[], TPrevious[]>, options: IDefaultInitializedParallelOptions, environment: ParallelEnvironmentDefinition, operations?: IParallelOperation[]);
    resolve(): IScheduledParallelChainState<TElement>;
    chainOperation<TElementNew>(operation: IParallelOperation): IParallelChainState<TElementNew>;
    addEnvironment(environment: IParallelChainEnvironment): IParallelChainState<TElement>;
}