/// <reference types="node" />
import { Readable, Stream } from 'stream';
import { IObservable } from './src/internal/Observable';
import { IObserver } from './src/internal/Observer';
import { ISubscription } from './src/internal/Subscription';
import { IScheduler } from './src/schedulers/Scheduler';
export { Observable } from './src/internal/Observable';
export declare class Air<T> implements IObservable<T> {
    private src;
    constructor(src: IObservable<T>);
    subscribe(observer: IObserver<T>, scheduler?: IScheduler): ISubscription;
    concatMap<S>(fn: (t: T) => IObservable<S>): Air<S>;
    concat(src: IObservable<T>): Air<T>;
    delay(t: number): Air<T>;
    filter(fn: (t: T) => boolean): Air<T>;
    flatMap<S>(fn: (t: T) => IObservable<S>): Air<S>;
    forEach(fn: (t: T) => void): ISubscription;
    join(): Air<{}>;
    mapTo<S>(t: S): Air<S>;
    map<S>(fn: (t: T) => S): Air<S>;
    mergeMap<S>(n: IObservable<number>, project: (t: T) => IObservable<S>): Air<S>;
    multicast(): Air<T>;
    reduce<R>(fn: (memory: R, current: T) => R, seed: R): Air<R>;
    sample(fn: (...e: Array<any>) => T, sources: Array<IObservable<any>>): Air<T>;
    skipRepeats(fn: (a: T, b: T) => boolean): Air<T>;
    slice(start: number, count: number): Air<T>;
    switchLatest(): Air<{}>;
    switchMap<S>(fn: (t: T) => IObservable<S>): Air<S>;
    tap(fn: (t: T) => void): Air<T>;
    uniqueWith(set: Set<any>): Air<any>;
    unique(): Air<T>;
    debounce(t: number): Air<T>;
    toNodeStream(): Stream;
    toPromise(): Promise<T>;
    scan<R>(reducer: (memory: R, current: T) => R, seed: R): Air<R>;
    static combine<T>(selector: (...t: any[]) => T, sources: IObservable<any>[]): Air<{}>;
    static fromNodeStream(node: Readable): Air<any>;
    static empty(): Air<void>;
    static frames(): Air<void>;
    static fromArray<T>(arr: Array<T>): Air<T>;
    static fromDOM(el: HTMLElement, event: string): Air<Event>;
    static fromPromise<T>(fn: () => Promise<T>): Air<T>;
    static interval(t: number): Air<void>;
    static just<T>(t: T): Air<T>;
    static never(): Air<any>;
    static of<T>(...t: T[]): Air<T>;
}