import { Monad } from "jabz/monad";
import { Consumer, Observer } from "./frp-common";
import { Behavior } from "./behavior";
/**
 * A future is a thing that occurs at some point in time with a value.
 * It can be understood as a pair consisting of the time the future
 * occurs and its associated value. It is quite like a JavaScript
 * promise.
 */
export declare abstract class Future<A> implements Monad<A>, Consumer<any> {
    occured: boolean;
    value: A;
    protected listeners: Consumer<A>[];
    constructor();
    listen(o: Consumer<A>): void;
    subscribe(f: (a: A) => void): void;
    abstract push(val: any): void;
    resolve(val: A): void;
    map<B>(f: (a: A) => B): Future<B>;
    mapTo<B>(b: B): Future<B>;
    static of<B>(b: B): Future<B>;
    of<B>(b: B): Future<B>;
    ap: <B>(f: Future<(a: A) => B>) => Future<B>;
    lift<T1, R>(f: (t: T1) => R, m: Future<T1>): Future<R>;
    lift<T1, T2, R>(f: (t: T1, u: T2) => R, m1: Future<T1>, m2: Future<T2>): Future<R>;
    lift<T1, T2, T3, R>(f: (t1: T1, t2: T2, t3: T3) => R, m1: Future<T1>, m2: Future<T2>, m3: Future<T3>): Future<R>;
    static multi: false;
    multi: boolean;
    chain<B>(f: (a: A) => Future<B>): Future<B>;
    flatten: <B>() => Future<B>;
}
export declare function sinkFuture<A>(): Future<A>;
export declare function fromPromise<A>(p: Promise<A>): Future<A>;
/**
 * Create a future from a pushing behavior. The future occurs when the
 * behavior pushes its next value. Constructing a BehaviorFuture is
 * impure and should not be done direcly.
 * @private
 */
export declare class BehaviorFuture<A> extends Future<A> implements Observer<A> {
    private b;
    constructor(b: Behavior<A>);
    endPulling(): void;
    beginPulling(): void;
    push(a: A): void;
}