1import { Observable } from './Observable';
2import { Subscription } from './Subscription';
3/** OPERATOR INTERFACES */
4export interface UnaryFunction<T, R> {
5    (source: T): R;
6}
7export interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
8}
9export declare type FactoryOrValue<T> = T | (() => T);
10export interface MonoTypeOperatorFunction<T> extends OperatorFunction<T, T> {
11}
12export interface Timestamp<T> {
13    value: T;
14    timestamp: number;
15}
16export interface TimeInterval<T> {
17    value: T;
18    interval: number;
19}
20/** SUBSCRIPTION INTERFACES */
21export interface Unsubscribable {
22    unsubscribe(): void;
23}
24export declare type TeardownLogic = Unsubscribable | Function | void;
25export interface SubscriptionLike extends Unsubscribable {
26    unsubscribe(): void;
27    readonly closed: boolean;
28}
29export declare type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>;
30/** OBSERVABLE INTERFACES */
31export interface Subscribable<T> {
32    subscribe(observer?: PartialObserver<T>): Unsubscribable;
33    /** @deprecated Use an observer instead of a complete callback */
34    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Unsubscribable;
35    /** @deprecated Use an observer instead of an error callback */
36    subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Unsubscribable;
37    /** @deprecated Use an observer instead of a complete callback */
38    subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Unsubscribable;
39    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Unsubscribable;
40}
41export declare type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T> | Iterable<T>;
42/** @deprecated use {@link InteropObservable } */
43export declare type ObservableLike<T> = InteropObservable<T>;
44export declare type InteropObservable<T> = {
45    [Symbol.observable]: () => Subscribable<T>;
46};
47/** OBSERVER INTERFACES */
48export interface NextObserver<T> {
49    closed?: boolean;
50    next: (value: T) => void;
51    error?: (err: any) => void;
52    complete?: () => void;
53}
54export interface ErrorObserver<T> {
55    closed?: boolean;
56    next?: (value: T) => void;
57    error: (err: any) => void;
58    complete?: () => void;
59}
60export interface CompletionObserver<T> {
61    closed?: boolean;
62    next?: (value: T) => void;
63    error?: (err: any) => void;
64    complete: () => void;
65}
66export declare type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>;
67export interface Observer<T> {
68    closed?: boolean;
69    next: (value: T) => void;
70    error: (err: any) => void;
71    complete: () => void;
72}
73/** SCHEDULER INTERFACES */
74export interface SchedulerLike {
75    now(): number;
76    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
77}
78export interface SchedulerAction<T> extends Subscription {
79    schedule(state?: T, delay?: number): Subscription;
80}
81export declare type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;
82export declare type ObservedValuesFromArray<X> = X extends Array<ObservableInput<infer T>> ? T : never;
83