import { MonoTypeOperatorFunction } from '../interfaces'; /** * Converts a higher-order Observable into a first-order Observable by * concatenating the inner Observables in order. * * Flattens an Observable-of-Observables by putting one * inner Observable after the other. * * * * Joins every Observable emitted by the source (a higher-order Observable), in * a serial fashion. It subscribes to each inner Observable only after the * previous inner Observable has completed, and merges all of their values into * the returned observable. * * __Warning:__ If the source Observable emits Observables quickly and * endlessly, and the inner Observables it emits generally complete slower than * the source emits, you can run into memory issues as the incoming Observables * collect in an unbounded buffer. * * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set * to `1`. * * @example For each click event, tick every second from 0 to 3, with no concurrency * var clicks = Rx.Observable.fromEvent(document, 'click'); * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4)); * var firstOrder = higherOrder.concatAll(); * firstOrder.subscribe(x => console.log(x)); * * // Results in the following: * // (results are not concurrent) * // For every click on the "document" it will emit values 0 to 3 spaced * // on a 1000ms interval * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 * * @see {@link combineAll} * @see {@link concat} * @see {@link concatMap} * @see {@link concatMapTo} * @see {@link exhaust} * @see {@link mergeAll} * @see {@link switch} * @see {@link zipAll} * * @return {Observable} An Observable emitting values from all the inner * Observables concatenated. * @method concatAll * @owner Observable */ export declare function concatAll(): MonoTypeOperatorFunction;