import * as F from "./index";
import { Accum, Dispose, EndHandler, EndProjection, Eq, ErrorHandler, EventStream, FlatAccum, Handler, Observable, Predicate, Projection, Property, ValueHandler, ValuesHandler } from "./index";
import * as Logic from "./operators/logic";
declare module "./Observable" {
    interface Observable<A> {
        subscribe(handler: Handler<A>): Dispose;
        awaiting(otherObservable: Observable<any>): Property<boolean>;
        onValue(f: ValueHandler<A>): Dispose;
        onValues(f: ValuesHandler<A>): Dispose;
        onError(f: ErrorHandler): Dispose;
        onEnd(f: EndHandler): Dispose;
        doAction(f: (val: A) => void): Observable<A>;
        doError(f: (err: Error) => void): Observable<A>;
        doEnd(f: () => void): Observable<A>;
        doLog(label?: string): Observable<A>;
        assign(obj: any, method: string, ...params: any[]): Dispose;
        log(label?: string): Dispose;
        map<B>(project: Projection<A, B>): Observable<B>;
        mapError<A>(project: Projection<Error, A>): Observable<A>;
        mapEnd(f: EndProjection<A>): Observable<A>;
        filter(predicate: Predicate<A> | Property<any>): Observable<A>;
        take(n: number): Observable<A>;
        takeUntil(trigger: Observable<any>): Observable<A>;
        takeWhile(f: Predicate<A> | Property<boolean>): Observable<A>;
        first(): Observable<A>;
        last(): Observable<A>;
        skip(n: number): Observable<A>;
        skipUntil(trigger: Observable<any>): Observable<A>;
        skipWhile(trigger: Predicate<A> | Property<boolean>): Observable<A>;
        skipErrors(): Observable<A>;
        flatMapLatest<B>(project: Projection<A, B | Observable<B>>): Observable<B>;
        flatMapFirst<B>(project: Projection<A, B | Observable<B>>): Observable<B>;
        flatMap<B>(project: Projection<A, B | Observable<B>>): Observable<B>;
        flatMapConcat<B>(project: Projection<A, B | Observable<B>>): Observable<B>;
        flatMapWithConcurrencyLimit<B>(limit: number, project: Projection<A, B | Observable<B>>): Observable<B>;
        flatMapError(project: Projection<Error, A | Observable<A>>): Observable<A>;
        startWith(value: A): Observable<A>;
        scan<B>(seed: B, f: Accum<B, A>): Property<B>;
        fold<B>(seed: B, f: Accum<B, A>): Property<B>;
        flatScan<B>(seed: B, f: FlatAccum<B, A>): Property<B>;
        reduce<B>(seed: B, f: Accum<B, A>): Property<B>;
        zip<B, C>(other: Observable<B>, f: (a: A, b: B) => C): EventStream<C>;
        merge(other: Observable<A>): EventStream<A>;
        concat(other: Observable<A>): EventStream<A>;
        combine<B, C>(other: Observable<B>, f: (a: A, b: B) => C): Property<C>;
        errors(): Observable<A>;
        throttle(delay: number): Observable<A>;
        debounce(delay: number): Observable<A>;
        debounceImmediate(delay: number): Observable<A>;
        delay(delay: number): Observable<A>;
        bufferingThrottle(minimumInterval: number): Observable<A>;
        slidingWindow(max: number, min?: number): Property<A[]>;
        skipDuplicates(isEqual?: Eq<A>): Observable<A>;
        diff<D>(start: A, f: F.Delta<A, D>): Observable<D>;
        toPromise(ctor?: PromiseConstructor): Promise<A>;
        firstToPromise(ctor?: PromiseConstructor): Promise<A>;
    }
}
declare module "./EventStream" {
    interface EventStream<A> {
        toProperty(initialValue?: A): Property<A>;
        doAction(f: (val: A) => void): EventStream<A>;
        doError(f: (err: Error) => void): EventStream<A>;
        doEnd(f: () => void): EventStream<A>;
        doLog(label?: string): EventStream<A>;
        map<B>(project: Projection<A, B>): EventStream<B>;
        mapError<A>(project: Projection<Error, A>): EventStream<A>;
        mapEnd(f: EndProjection<A>): EventStream<A>;
        filter(predicate: Predicate<A> | Property<any>): EventStream<A>;
        take(n: number): EventStream<A>;
        takeUntil(trigger: Observable<any>): EventStream<A>;
        takeWhile(f: Predicate<A> | Property<boolean>): EventStream<A>;
        first(): EventStream<A>;
        last(): EventStream<A>;
        skip(n: number): EventStream<A>;
        skipUntil(trigger: Observable<any>): EventStream<A>;
        skipWhile(trigger: Predicate<A> | Property<boolean>): EventStream<A>;
        skipErrors(): EventStream<A>;
        flatMapLatest<B>(project: Projection<A, B | Observable<B>>): EventStream<B>;
        flatMapFirst<B>(project: Projection<A, B | Observable<B>>): EventStream<B>;
        flatMap<B>(project: Projection<A, B | Observable<B>>): EventStream<B>;
        flatMapConcat<B>(project: Projection<A, B | Observable<B>>): EventStream<B>;
        flatMapWithConcurrencyLimit<B>(limit: number, project: Projection<A, B | Observable<B>>): EventStream<B>;
        flatMapError(project: Projection<Error, A | Observable<A>>): EventStream<A>;
        startWith(value: A): EventStream<A>;
        errors(): EventStream<A>;
        throttle(delay: number): EventStream<A>;
        debounce(delay: number): EventStream<A>;
        debounceImmediate(delay: number): EventStream<A>;
        delay(delay: number): EventStream<A>;
        bufferingThrottle(minimumInterval: number): EventStream<A>;
        bufferWithTime(delay: number): EventStream<A[]>;
        bufferWithCount(count: number): EventStream<A[]>;
        bufferWithTimeOrCount(delay: number, count: number): EventStream<A[]>;
        skipDuplicates(isEqual?: Eq<A>): EventStream<A>;
        diff<D>(start: A, f: F.Delta<A, D>): EventStream<D>;
    }
}
declare module "./Property" {
    interface Property<A> {
        toEventStream(): EventStream<A>;
        changes(): EventStream<A>;
        doAction(f: (val: A) => void): Property<A>;
        doError(f: (err: Error) => void): Property<A>;
        doEnd(f: () => void): Property<A>;
        doLog(label?: string): Property<A>;
        map<B>(project: Projection<A, B>): Property<B>;
        mapError<A>(project: Projection<Error, A>): Property<A>;
        mapEnd(f: EndProjection<A>): Property<A>;
        filter(predicate: Predicate<A> | Property<any>): Property<A>;
        take(n: number): Property<A>;
        takeUntil(trigger: Observable<any>): Property<A>;
        takeWhile(f: Predicate<A> | Property<boolean>): Property<A>;
        first(): Property<A>;
        last(): Property<A>;
        skip(n: number): Property<A>;
        skipUntil(trigger: Observable<any>): Property<A>;
        skipWhile(trigger: Predicate<A> | Property<boolean>): Property<A>;
        skipErrors(): Property<A>;
        flatMapLatest<B>(project: Projection<A, B | Observable<B>>): Property<B>;
        flatMapFirst<B>(project: Projection<A, B | Observable<B>>): Property<B>;
        flatMap<B>(project: Projection<A, B | Observable<B>>): Property<B>;
        flatMapConcat<B>(project: Projection<A, B | Observable<B>>): Property<B>;
        flatMapWithConcurrencyLimit<B>(limit: number, project: Projection<A, B | Observable<B>>): Property<B>;
        flatMapError(project: Projection<Error, A | Observable<A>>): Property<A>;
        sampledBy<B>(sampler: EventStream<B>): EventStream<A>;
        sampledBy<B>(sampler: Property<B>): Property<A>;
        sampledBy<B, C>(sampler: EventStream<B>, f: SampleFn<A, B, C>): EventStream<C>;
        sampledBy<B, C>(sampler: Property<B>, f: SampleFn<A, B, C>): Property<C>;
        sample(interval: number): EventStream<A>;
        startWith(value: A): Property<A>;
        and<B>(other: Property<B>): Property<Logic.Result<A, B>>;
        or<B>(other: Property<B>): Property<Logic.Result<A, B>>;
        not<B>(): Property<boolean>;
        errors(): Property<A>;
        throttle(delay: number): Property<A>;
        debounce(delay: number): Property<A>;
        debounceImmediate(delay: number): Property<A>;
        delay(delay: number): Property<A>;
        bufferingThrottle(minimumInterval: number): Property<A>;
        skipDuplicates(isEqual?: Eq<A>): Property<A>;
        diff<D>(start: A, f: F.Delta<A, D>): Property<D>;
    }
}
declare module "./Bus" {
    interface Bus<T> {
        push(event: T | F.AnyEvent<T>): void;
        end(): void;
        error(err: Error): void;
        plug(obs: Observable<T>): F.Dispose;
    }
}
export declare type SampleFn<V, S, R> = (value: V, sample: S) => R;
export { End, Error, Next } from "./Event";
export { EventStream } from "./EventStream";
export { Observable } from "./Observable";
export { Property } from "./Property";
export { Bus } from "./Bus";
export { Combineable, combineAsArray, combineTemplate } from "./operators/combine";
export { update } from "./operators/update";
export { when } from "./operators/when";
export { zipAsArray } from "./operators/zip";
export { fromArray } from "./sources/fromArray";
export { fromBinder } from "./sources/fromBinder";
export { fromPromise } from "./sources/fromPromise";
export { never } from "./sources/never";
export { repeat } from "./sources/repeat";
export { constant, once } from "./sources/single";
export * from "./_interfaces";
export declare function later<T>(delay: number): EventStream<undefined>;
export declare function later<T>(delay: number, value: T): EventStream<T>;
export declare function interval<T>(period: number): EventStream<undefined>;
export declare function interval<T>(period: number, value: T): EventStream<T>;
export declare function fromEvent<T>(target: EventTarget, event: string, ...args: any[]): EventStream<T>;
export declare function fromPoll<T>(interval: number, f: () => T | F.AnyEvent<T>): EventStream<T>;
export declare function repeatedly<T>(interval: number, events: Array<T | F.AnyEvent<T>>): EventStream<T>;
export declare function sequentially<T>(interval: number, events: Array<T | F.AnyEvent<T>>): EventStream<T>;
export declare function fromCallback<T>(f: F.AsyncCallback<T>, ...args: any[]): EventStream<T>;
export declare function fromNodeCallback<T>(f: F.AsyncNodeCallback<T>, ...args: any[]): EventStream<T>;
export declare function zipWith<A, T>(f: (a: A) => T, streams: [Observable<A>]): EventStream<T>;
export declare function zipWith<A, B, T>(f: (a: A, b: B) => T, streams: [Observable<A>, Observable<B>]): EventStream<T>;
export declare function zipWith<A, B, C, T>(f: (a: A, b: B, c: C) => T, streams: [Observable<A>, Observable<B>, Observable<C>]): EventStream<T>;
export declare function zipWith<A, B, C, D, T>(f: (a: A, b: B, c: C, d: D) => T, streams: [Observable<A>, Observable<B>, Observable<C>, Observable<D>]): EventStream<T>;
export declare function zipWith<A, B, C, D, E, T>(f: (a: A, b: B, c: C, d: D, e: E) => T, streams: [Observable<A>, Observable<B>, Observable<C>, Observable<D>, Observable<E>]): EventStream<T>;
export declare function zipWith<A, B, C, D, E, F, T>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => T, streams: [Observable<A>, Observable<B>, Observable<C>, Observable<D>, Observable<E>, Observable<F>]): EventStream<T>;
export declare function zipWith<A, T>(f: (...args: A[]) => T, streams: A[]): EventStream<T>;
export declare function zipWith<A, T>(f: (streams: [Observable<A>], a: A) => T): EventStream<T>;
export declare function zipWith<A, B, T>(streams: [Observable<A>, Observable<B>], f: (a: A, b: B) => T): EventStream<T>;
export declare function zipWith<A, B, C, T>(streams: [Observable<A>, Observable<B>, Observable<C>], f: (a: A, b: B, c: C) => T): EventStream<T>;
export declare function zipWith<A, B, C, D, T>(streams: [Observable<A>, Observable<B>, Observable<C>, Observable<D>], f: (a: A, b: B, c: C, d: D) => T): EventStream<T>;
export declare function zipWith<A, B, C, D, E, T>(streams: [Observable<A>, Observable<B>, Observable<C>, Observable<D>, Observable<E>], f: (a: A, b: B, c: C, d: D, e: E) => T): EventStream<T>;
export declare function zipWith<A, B, C, D, E, F, T>(streams: [Observable<A>, Observable<B>, Observable<C>, Observable<D>, Observable<E>, Observable<F>], f: (a: A, b: B, c: C, d: D, e: E, f: F) => T): EventStream<T>;
export declare function zipWith<A, T>(streams: A[], f: (...args: A[]) => T): EventStream<T>;
export declare function combineWith<A, R>(f: (a: A) => R, observables: [F.Combineable<A>]): Property<R>;
export declare function combineWith<A, B, R>(f: (a: A, b: B) => R, observables: [F.Combineable<A>, F.Combineable<B>]): Property<R>;
export declare function combineWith<A, B, C, R>(f: (a: A, b: B, c: C) => R, observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>]): Property<R>;
export declare function combineWith<A, B, C, D, R>(f: (a: A, b: B, c: C, d: D) => R, observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>, F.Combineable<D>]): Property<R>;
export declare function combineWith<A, B, C, D, E, R>(f: (a: A, b: B, c: C, d: D, e: E) => R, observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>, F.Combineable<D>, F.Combineable<E>]): Property<R>;
export declare function combineWith<A, B, C, D, E, F, R>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => R, observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>, F.Combineable<D>, F.Combineable<E>, F.Combineable<F>]): Property<R>;
export declare function combineWith<A, R>(observables: [F.Combineable<A>], f: (a: A) => R): Property<R>;
export declare function combineWith<A, B, R>(observables: [F.Combineable<A>, F.Combineable<B>], f: (a: A, b: B) => R): Property<R>;
export declare function combineWith<A, B, C, R>(observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>], f: (a: A, b: B, c: C) => R): Property<R>;
export declare function combineWith<A, B, C, D, R>(observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>, F.Combineable<D>], f: (a: A, b: B, c: C, d: D) => R): Property<R>;
export declare function combineWith<A, B, C, D, E, R>(observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>, F.Combineable<D>, F.Combineable<E>], f: (a: A, b: B, c: C, d: D, e: E) => R): Property<R>;
export declare function combineWith<A, B, C, D, E, F, R>(observables: [F.Combineable<A>, F.Combineable<B>, F.Combineable<C>, F.Combineable<D>, F.Combineable<E>, F.Combineable<F>], f: (a: A, b: B, c: C, d: D, e: E, f: F) => R): Property<R>;
export declare function concatAll<T>(...observables: Array<Observable<T>>): EventStream<T>;
export declare function concatAll<T>(observables: Array<Observable<T>>): EventStream<T>;
export declare function mergeAll<T>(...observables: Array<Observable<T>>): EventStream<T>;
export declare function mergeAll<T>(observables: Array<Observable<T>>): EventStream<T>;