import { Observable, Operator } from './common';
import * as producer from './producer';
import { subscribe, toPromise, toReadableStream } from './utils';
import * as combination from './combination';
declare const observables: {
    subject<T>(source?: Observable<T>): producer.Subject<T>;
    defer<T>(f: () => Observable<T>): Observable<T>;
    of<T>(...data: T[]): Observable<T>;
    fromArray<T>(data: ArrayLike<T>): Observable<T>;
    interval(period: number): Observable<number>;
    timer(delay: number, period?: number): Observable<number>;
    fromEventPattern<T>(add: (n: import("./common").EventHandler<T>) => void, remove: (n: import("./common").EventHandler<T>) => void): Observable<T>;
    fromEvent<T, N>(target: import("./common").EventDispachter<N, T>, name: N): Observable<T>;
    fromPromise<T>(promise: Promise<T>): Observable<T>;
    fromFetch(input: RequestInfo, init?: RequestInit): Observable<Response>;
    fromIterable<T>(source: Iterable<T>): Observable<T>;
    fromReader<T>(source: ReadableStreamDefaultReader<T>): Observable<T>;
    fromReadableStream<T>(source: ReadableStream<T>): Observable<T>;
    fromAnimationFrame(): Observable<DOMHighResTimeStamp>;
    range(start: number, count: number): Observable<number>;
    bindCallback<T>(call: Function, thisArg: any, ...args: any[]): Observable<T>;
    bindNodeCallback<T>(call: Function, thisArg: any, ...args: any[]): Observable<T>;
    never(): Observable<never>;
    throwError(e: any): Observable<never>;
    empty(): Observable<never>;
    zip: typeof combination.zip;
    merge: typeof combination.merge;
    race: typeof combination.race;
    concat: typeof combination.concat;
    combineLatest: typeof combination.combineLatest;
};
declare const operators: {
    share<T>(): Operator<T>;
    shareReplay<T>(bufferSize: number): Operator<T>;
    iif<T, F>(condition: () => boolean, trueS: Observable<T>, falseS: Observable<F>): Observable<T | F>;
    startWith<T, A extends unknown[]>(...xs: A): Operator<T, T | A[number]>;
    withLatestFrom: <T, A extends unknown[]>(...args: import("./common").ObservableInputTuple<A>) => Operator<T, [T, ...A]>;
    bufferCount: <T>(bufferSize: number, startBufferEvery?: number | undefined) => Operator<T, T[]>;
    buffer: <T>(closingNotifier: Observable<unknown>) => Operator<T, T[]>;
    reduce: <T, R, ACC extends R | T>(f: (acc: ACC, c: T) => ACC, seed?: ACC | undefined) => Operator<T, ACC>;
    count: <T>(f: (d: T) => boolean) => Operator<T, number>;
    max: () => Operator<number, number>;
    min: () => Operator<number, number>;
    sum: () => Operator<number, number>;
    filter: <T>(filter: (data: T) => boolean, thisArg?: any) => Operator<T, T>;
    distinct<T, K = T>(keySelector?: (data: T) => K): Operator<T, T>;
    ignoreElements: <T>() => Operator<T, never>;
    take: <T>(count: number) => Operator<T, T>;
    takeUntil: <T>(control: Observable<unknown>) => Operator<T, T>;
    takeWhile: <T>(f: (data: T) => boolean) => Operator<T, T>;
    takeLast: <T>(count: number) => Operator<T, T[]>;
    skip: <T>(count: number) => Operator<T, T>;
    skipUntil: <T>(control: Observable<unknown>) => Operator<T, T>;
    skipWhile: <T>(f: (data: T) => boolean) => Operator<T, T>;
    throttle: <T>(durationSelector: (data: T) => Observable<unknown>, config?: {
        leading: boolean;
        trailing: boolean;
    } | undefined) => Operator<T, T>;
    audit: <T>(durationSelector: (d: T) => Observable<unknown>) => Operator<T, T>;
    debounce: <T>(durationSelector: (d: T) => Observable<unknown>) => Operator<T, T>;
    debounceTime: <T>(period: number) => Operator<T, T>;
    elementAt: <T>(count: number, defaultValue?: T | undefined) => Operator<T, T>;
    find: <T>(f: (d: T) => boolean) => (source: Observable<T>) => Observable<T>;
    findIndex: <T>(f: (d: T) => boolean) => Operator<T, number>;
    first: <T>(f?: ((d: T, index: number) => boolean) | undefined, defaultValue?: T | undefined) => Operator<T, T>;
    last: <T>(f?: ((d: T, index: number) => boolean) | undefined, defaultValue?: T | undefined) => Operator<T, T>;
    every: <T>(predicate: (d: T, index: number) => boolean) => Operator<T, boolean>;
    scan: <T, R, ACC extends R | T>(f: (acc: ACC, c: T) => ACC, seed?: ACC | undefined) => Operator<T, ACC>;
    pairwise: <T>() => Operator<T, [T, T]>;
    map: <T, R>(mapper: (data: T) => R, thisArg?: any) => Operator<T, R>;
    mapTo: <R>(target: R) => Operator<unknown, R>;
    switchMap: <T, U, R = U>(makeSource: (data: T, index: number) => Observable<U>, combineResults?: ((outter: T, inner: U) => R) | undefined) => Operator<T, R>;
    switchMapTo: (innerSource: Observable<unknown>, combineResults?: ((outter: unknown, inner: unknown) => unknown) | undefined) => Operator<unknown, unknown>;
    concatMap: <T, U, R = U>(makeSource: (data: T, index: number) => Observable<U>, combineResults?: ((outter: T, inner: U) => R) | undefined) => Operator<T, R>;
    concatMapTo: (innerSource: Observable<unknown>, combineResults?: ((outter: unknown, inner: unknown) => unknown) | undefined) => Operator<unknown, unknown>;
    mergeMap: <T, U, R = U>(makeSource: (data: T, index: number) => Observable<U>, combineResults?: ((outter: T, inner: U) => R) | undefined) => Operator<T, R>;
    mergeMapTo: (innerSource: Observable<unknown>, combineResults?: ((outter: unknown, inner: unknown) => unknown) | undefined) => Operator<unknown, unknown>;
    exhaustMap: <T, U, R = U>(makeSource: (data: T, index: number) => Observable<U>, combineResults?: ((outter: T, inner: U) => R) | undefined) => Operator<T, R>;
    exhaustMapTo: (innerSource: Observable<unknown>, combineResults?: ((outter: unknown, inner: unknown) => unknown) | undefined) => Operator<unknown, unknown>;
    groupBy: <T>(f: (data: T) => any) => Operator<T, Observable<unknown> & import("./common").Observer<unknown> & {
        key: any;
    }>;
    timeInterval: <T>() => Operator<T, {
        value: T;
        interval: number;
    }>;
    bufferTime: <T>(miniseconds: number) => Operator<T, T[]>;
    delay: <T>(delay: number) => Operator<T, T>;
    catchError: <T, R = T>(selector: (err: any) => Observable<R>) => Operator<T, R>;
    expand: <T>(project: (value: T, index: number) => Observable<T>) => Operator<T, T>;
    tap: <T>(ob: Partial<import("./common").Observer<T>> | ((d: T) => void)) => Operator<T, T>;
    timeout: <T>(timeout: number) => Operator<T, T>;
};
type Obs = {
    subscribe: typeof subscribe;
    toPromise: typeof toPromise;
    toReadableStream: typeof toReadableStream;
};
type Op = {
    [key in keyof (typeof operators)]: (...args: Parameters<((typeof operators))[key]>) => Op;
} & Obs;
type Rx = {
    [key in keyof typeof observables]: (...args: Parameters<(typeof observables)[key]>) => Op;
};
export declare const rx: Rx;
export {};
//# sourceMappingURL=chain.d.ts.map