/** @module hareactive/behavior */
import { Observer } from "./frp-common";
import { Future } from "./Future";
import { Stream } from "./Stream";
/**
 * A behavior is a value that changes over time. Conceptually it can
 * be though of as a function from time to a value. I.e. `type
 * Behavior<A> = (t: Time) => A`.
 */
export declare abstract class Behavior<A> implements Observer<A> {
    pushing: boolean;
    last: A;
    nrOfListeners: number;
    child: Observer<any>;
    abstract push(a: any): void;
    abstract pull(): A;
    constructor();
    map<B>(fn: (a: A) => B): Behavior<B>;
    of: <A>(v: A) => Behavior<A>;
    static of: <A>(v: A) => Behavior<A>;
    ap<B>(f: Behavior<(a: A) => B>): Behavior<B>;
    lift<T1, R>(f: (t: T1) => R, m: Behavior<T1>): Behavior<R>;
    lift<T1, T2, R>(f: (t: T1, u: T2) => R, m1: Behavior<T1>, m2: Behavior<T2>): Behavior<R>;
    lift<T1, T2, T3, R>(f: (t1: T1, t2: T2, t3: T3) => R, m1: Behavior<T1>, m2: Behavior<T2>, m3: Behavior<T3>): Behavior<R>;
    chain<B>(fn: (a: A) => Behavior<B>): Behavior<B>;
    endPulling(): void;
    beginPulling(): void;
    subscribe(cb: (a: A) => void): Observer<A>;
    addListener(c: Observer<A>): void;
    removeListener(listener: Observer<any>): void;
}
export declare function of<B>(val: B): Behavior<B>;
export declare function at<B>(b: Behavior<B>): B;
/**
 * Map a function over a behavior. This means that if at some point in
 * time the value of `b` is `bVal` then the value of the returned
 * behavior is `fn(bVal)`.
 */
export declare function map<A, B>(fn: (a: A) => B, b: Behavior<A>): Behavior<B>;
/**
 * Apply a function valued behavior to a value behavior.
 *
 * @param fnB behavior of functions from `A` to `B`
 * @param valB A behavior of `A`
 * @returns Behavior of the function in `fnB` applied to the value in `valB`
 */
export declare function ap<A, B>(fnB: Behavior<(a: A) => B>, valB: Behavior<A>): Behavior<B>;
/**
 * Creates a behavior for imperative impure pushing.
 */
export declare function sink<A>(initialValue: A): Behavior<A>;
/**
 * A placeholder behavior is a behavior without any value. It is used
 * to do value recursion in `./framework.ts`.
 * @private
 */
export declare class PlaceholderBehavior<B> extends Behavior<B> {
    private source;
    constructor();
    push(v: B): void;
    pull(): B;
    replaceWith(b: Behavior<B>): void;
}
export declare function placeholder(): PlaceholderBehavior<any>;
/**
 * Take a behavior `b` of booleans and return a behavior that for time
 * `t` contains a future that occurs when `b` is true after `t`.
 * @param b - A boolean valued behavior.
 */
export declare function when(b: Behavior<boolean>): Behavior<Future<{}>>;
/**
 * Creates a future than on occurence samples the current value of the
 * behavior and occurs with that value. That is, the original value of
 * the future is overwritten with the behavior value at the time when
 * the future occurs.
 */
export declare function snapshot<A>(behavior: Behavior<A>, future: Future<any>): Behavior<Future<A>>;
/**
 * From an initial behavior and a future of a behavior `switcher`
 * creates a new behavior that acts exactly like `initial` until
 * `next` occurs after which it acts like the behavior it contains.
 */
export declare function switcher<A>(init: Behavior<A>, next: Future<Behavior<A>>): Behavior<A>;
/**
 * Creates a Behavior whose value is the last occurrence in the stream.
 * @param initial the initial value that the behavior has
 * @param steps the stream that will change the value of the behavior
 */
export declare function stepper<B>(initial: B, steps: Stream<B>): Behavior<B>;
/**
 * The returned behavior 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 scan<A, B>(fn: (a: A, b: B) => B, init: B, source: Stream<A>): Behavior<Behavior<B>>;
/**
 * This takes an impure function that varies over time and returns a
 * pull-driven behavior. This is particulairly useful if the function
 * is contionusly changing, like `Date.now`.
 */
export declare function fromFunction<B>(fn: () => B): Behavior<B>;
/**
 * Subscribe to a behavior in order to run imperative actions when the
 * value in the behavior changes.
 */
export declare function subscribe<A>(fn: (a: A) => void, b: Behavior<A>): void;
export declare class CbObserver<A> implements Observer<A> {
    private _push;
    private _beginPulling;
    private _endPulling;
    private source;
    constructor(_push: (a: A) => void, _beginPulling: () => void, _endPulling: () => void, source: Behavior<A>);
    push(a: A): void;
    beginPulling(): void;
    endPulling(): void;
}
/**
 * Observe a behavior for the purpose of executing imperative actions
 * based on the value of the behavior.
 */
export declare function observe<A>(push: (a: A) => void, beginPulling: () => void, endPulling: () => void, b: Behavior<A>): CbObserver<A>;
/**
 * Imperatively push a value into a behavior.
 */
export declare function publish<A>(a: A, b: Behavior<A>): void;
export declare function isBehavior(b: any): b is Behavior<any>;
export declare type Time = number;
/**
 * A behavior whose value is the number of milliseconds elapsed win
 * UNIX epoch. I.e. its current value is equal to the value got by
 * calling `Date.now`.
 */
export declare const time: Behavior<Time>;
/**
 * A behavior giving access to continous time. When sampled the outer
 * behavior gives a behavior with values that contain the difference
 * between the current sample time and the time at which the outer
 * behavior was sampled.
 */
export declare const timeFrom: Behavior<Behavior<Time>>;
export declare function lift<T1, R>(f: (t: T1) => R, m: Behavior<T1>): Behavior<R>;
export declare function lift<T1, T2, R>(f: (t: T1, u: T2) => R, m1: Behavior<T1>, m2: Behavior<T2>): Behavior<R>;
export declare function lift<T1, T2, T3, R>(f: (t1: T1, t2: T2, t3: T3) => R, m1: Behavior<T1>, m2: Behavior<T2>, m3: Behavior<T3>): Behavior<R>;