/** @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>;
    combine<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>>;
    delay(ms: number): Stream<A>;
    throttle(ms: number): Stream<A>;
    debounce(ms: number): Stream<A>;
}
/** @private */
export declare class SinkStream<A> extends Stream<A> {
    push(a: A): void;
}
export declare function debounce<A>(ms: number, stream: Stream<A>): Stream<A>;
export declare function throttle<A>(ms: number, stream: Stream<A>): Stream<A>;
export declare function delay<A>(ms: number, stream: Stream<A>): Stream<A>;
export declare function apply<A, B>(behavior: Behavior<(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>(predicate: (a: A) => boolean, s: Stream<A>): Stream<A>;
export declare function split<A>(predicate: (a: A) => boolean, stream: Stream<A>): [Stream<A>, Stream<A>];
export declare function filterApply<A>(predicate: Behavior<(a: A) => boolean>, stream: Stream<A>): Stream<A>;
export declare function keepWhen<A>(stream: Stream<A>, behavior: Behavior<boolean>): 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>(b: Behavior<B>, s: Stream<any>): Stream<B>;
export declare function snapshotWith<A, B, C>(f: (a: A, b: B) => C, b: Behavior<B>, s: Stream<A>): Stream<C>;
export declare function switchStream<A>(b: Behavior<Stream<A>>): Stream<A>;
export declare function changes<A>(b: Behavior<A>): Stream<A>;
export declare class PlaceholderStream<B> extends Stream<B> {
    private source;
    push(a: B): void;
    replaceWith(s: Stream<B>): void;
}
export declare function placeholderStream<A>(): PlaceholderStream<A>;
export declare function combineList<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 combine<A, B>(a: Stream<A>, b: Stream<B>): Stream<(A | B)>;
export declare function isStream(s: any): s is Stream<any>;