/**
 * A stream of elements offering a functional interface to manipulate elements.
 * Typically the elements are generated/retrieved lazily.
 */
export declare abstract class Stream<T> implements AsyncIterable<T> {
    [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
    iterator(): AsyncIterator<T, any, undefined>;
    /**
     * Collects all the answers from this stream into an array
     * ### Examples
     *
     * ```ts
     * results = transaction.query.match(query).collect().await;
     * ```
     */
    collect(): Promise<T[]>;
    /**
     * Checks whether a condition is satisfied by ALL answers in this stream.
     * @param callbackFn: The condition to evaluate.
     * ### Examples
     *
     * ```ts
     * // For a query "match $a isa age;", check if all results for $a are positive.
     * results = transaction.query.match(query).every(cm => cm.get("a").value > 0).await;
     * ```
     */
    every(callbackFn: (value: T) => unknown): Promise<boolean>;
    /**
     * Checks whether a condition is satisfied by ANY answer in this stream.
     * @param callbackFn: The condition to evaluate.
     * ### Examples
     *
     * ```ts
     * // For a query "match $a isa age;", check if any results for $a are negative.
     * results = transaction.query.match(query).some(cm => cm.get("a").value < 0).await;
     * ```
     */
    some(callbackFn: (value: T) => unknown): Promise<boolean>;
    /**
     * Returns a new stream from this stream consisting only of elements which satisfy a given condition.
     * @param filter - The condition to evaluate.
     * ### Examples
     *
     * ```ts
     * // For a query "match $p isa person, has age $a;", only retrieve results having $a >= 60.
     * results = transaction.query.match(query).filter(cm => cm.get("a").value > 60).collect();
     * ```
     */
    filter(filter: (value: T) => boolean): Stream<T>;
    /**
     * @param mapper - The mapping function to apply.
     * Returns a new stream from this stream by applying the <code>mapper</code> function to each element.
     */
    map<U>(mapper: (value: T) => U): Stream<U>;
    /**
     * Given a function which accepts a single element of this stream and returns a new stream,
     * This function returns a new stream obtained by applying the function to each element in the stream,
     * and concatenating each result thus obtained
     * @param mapper - The mapping function to apply. Must return a stream.
     */
    flatMap<U>(mapper: (value: T) => Stream<U>): Stream<U>;
    /**
     * Executes the given function for each element in the stream.
     * @param fn - The function to evaluate for each element.
     */
    forEach(fn: (value: T) => void): Promise<void>;
    /**
     * Returns the first element in the stream.
     */
    first(): Promise<T | null>;
}
/** @ignore */
export declare namespace Stream {
    export function iterable<T>(iterable: AsyncIterable<T>): Iterable<T>;
    export function promises<T>(items: Promise<T>[]): PromiseArray<T>;
    export function array<T>(items: T[]): Array<T>;
    class Iterable<T> extends Stream<T> {
        private _provider;
        constructor(provider: AsyncIterable<T>);
        [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
    }
    class Array<T> extends Stream<T> {
        private readonly _array;
        constructor(array: T[]);
        [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
    }
    class PromiseArray<T> extends Stream<T> {
        private readonly _array;
        constructor(array: Promise<T>[]);
        [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
    }
    export class Filtered<T> extends Stream<T> {
        private _filter;
        private _source;
        constructor(source: Stream<T>, filter: (value: T) => boolean);
        [Symbol.asyncIterator](): AsyncIterator<T, any, undefined>;
    }
    export class Mapped<T, U> extends Stream<U> {
        private _source;
        private _mapper;
        constructor(source: Stream<T>, mapper: (value: T) => U);
        [Symbol.asyncIterator](): AsyncIterator<U, any, undefined>;
    }
    export class FlatMapped<T, U, S extends Stream<U>> extends Stream<U> {
        private _source;
        private _flatMapper;
        constructor(source: Stream<T>, flatMapper: (value: T) => Stream<U>);
        [Symbol.asyncIterator](): AsyncIterator<U, any, undefined>;
    }
    export {};
}