1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
| import { Operator } from './Operator';
| import { Subscriber } from './Subscriber';
| import { Subscription } from './Subscription';
| import { TeardownLogic, OperatorFunction, PartialObserver, Subscribable } from './types';
| import { iif } from './observable/iif';
| import { throwError } from './observable/throwError';
| /**
| * A representation of any set of values over any amount of time. This is the most basic building block
| * of RxJS.
| *
| * @class Observable<T>
| */
| export declare class Observable<T> implements Subscribable<T> {
| /** Internal implementation detail, do not use directly. */
| _isScalar: boolean;
| /** @deprecated This is an internal implementation detail, do not use. */
| source: Observable<any>;
| /** @deprecated This is an internal implementation detail, do not use. */
| operator: Operator<any, T>;
| /**
| * @constructor
| * @param {Function} subscribe the function that is called when the Observable is
| * initially subscribed to. This function is given a Subscriber, to which new values
| * can be `next`ed, or an `error` method can be called to raise an error, or
| * `complete` can be called to notify of a successful completion.
| */
| constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
| /**
| * Creates a new cold Observable by calling the Observable constructor
| * @static true
| * @owner Observable
| * @method create
| * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
| * @return {Observable} a new cold observable
| * @nocollapse
| * @deprecated use new Observable() instead
| */
| static create: Function;
| /**
| * Creates a new Observable, with this Observable as the source, and the passed
| * operator defined as the new observable's operator.
| * @method lift
| * @param {Operator} operator the operator defining the operation to take on the observable
| * @return {Observable} a new observable with the Operator applied
| */
| lift<R>(operator: Operator<T, R>): Observable<R>;
| subscribe(observer?: PartialObserver<T>): Subscription;
| /** @deprecated Use an observer instead of a complete callback */
| subscribe(next: null | undefined, error: null | undefined, complete: () => void): Subscription;
| /** @deprecated Use an observer instead of an error callback */
| subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Subscription;
| /** @deprecated Use an observer instead of a complete callback */
| subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Subscription;
| subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
| /** @deprecated This is an internal implementation detail, do not use. */
| _trySubscribe(sink: Subscriber<T>): TeardownLogic;
| /**
| * @method forEach
| * @param {Function} next a handler for each value emitted by the observable
| * @param {PromiseConstructor} [promiseCtor] a constructor function used to instantiate the Promise
| * @return {Promise} a promise that either resolves on observable completion or
| * rejects with the handled error
| */
| forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promise<void>;
| /** @internal This is an internal implementation detail, do not use. */
| _subscribe(subscriber: Subscriber<any>): TeardownLogic;
| /**
| * @nocollapse
| * @deprecated In favor of iif creation function: import { iif } from 'rxjs';
| */
| static if: typeof iif;
| /**
| * @nocollapse
| * @deprecated In favor of throwError creation function: import { throwError } from 'rxjs';
| */
| static throw: typeof throwError;
| pipe(): Observable<T>;
| pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
| pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
| pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
| pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
| pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
| pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
| pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
| pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
| pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
| pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<{}>;
| toPromise<T>(this: Observable<T>): Promise<T>;
| toPromise<T>(this: Observable<T>, PromiseCtor: typeof Promise): Promise<T>;
| toPromise<T>(this: Observable<T>, PromiseCtor: PromiseConstructorLike): Promise<T>;
| }
|
|
