/** @module hareactive/stream */
import { Reactive } from "./frp-common";
import { Behavior } from "./Behavior";
/**
 * A stream is a list of occurences over time. Each occurence happens
 * at a discrete point in time and has an associated value.
 * Semantically it is a list `type Stream<A> = [Time, A]`.
 */
export declare abstract class Stream<A> extends Reactive<A> {
    constructor();
    abstract push(a: any): void;
    map<B>(fn: (a: A) => B): Stream<B>;
    mapTo<B>(val: B): Stream<B>;
    merge<B>(otherStream: Stream<B>): Stream<(A | B)>;
    filter(fn: (a: A) => boolean): Stream<A>;
    scanS<B>(fn: (a: A, b: B) => B, startingValue: B): Behavior<Stream<B>>;
    scan<B>(fn: (a: A, b: B) => B, init: B): Behavior<Behavior<B>>;
}
/** @private */
export declare class SinkStream<A> extends Stream<A> {
    push(a: A): void;
}
export declare function map<A, B>(fn: (a: A) => B, stream: Stream<A>): Stream<B>;
/**
 * @param fn A predicate function that returns a boolean for `A`.
 * @param stream The stream to filter.
 * @returns Stream that only contains the occurences from `stream`
 * for which `fn` returns true.
 */
export declare function filter<A>(fn: (a: A) => boolean, stream: Stream<A>): Stream<A>;
/**
 * The returned  initially has the initial value, on each
 * occurence in `source` the function is applied to the current value
 * of the behaviour and the value of the occurence, the returned value
 * becomes the next value of the behavior.
 */
export declare function scanS<A, B>(fn: (a: A, b: B) => B, startingValue: B, stream: Stream<A>): Behavior<Stream<B>>;
export declare function snapshot<B>(behavior: Behavior<B>, stream: Stream<any>): Stream<B>;
export declare function snapshotWith<A, B, C>(fn: (a: A, b: B) => C, behavior: Behavior<B>, stream: Stream<A>): Stream<C>;
/**
 * Takes a stream valued behavior and returns at stream that emits
 * values from the current stream at the behavior. I.e. the returned
 * stream always "switches" to the current stream at the behavior.
 */
export declare function switchStream<A>(b: Behavior<Stream<A>>): Stream<A>;
export declare function changes<A>(b: Behavior<A>): Stream<A>;
export declare function mergeList<A>(ss: Stream<A>[]): Stream<A>;
/**
 * @returns A stream that never has any occurrences.
 */
export declare function empty<A>(): Stream<A>;
export declare function subscribe<A>(fn: (a: A) => void, stream: Stream<A>): void;
export declare function publish<A>(a: A, stream: Stream<A>): void;
export declare function merge<A, B>(a: Stream<A>, b: Stream<B>): Stream<(A | B)>;
export declare function isStream(obj: any): boolean;