1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 | declare namespace Rx {
|
10 | namespace internals {
|
11 | function isEqual(left: any, right: any): boolean;
|
12 | function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
|
13 |
|
14 |
|
15 | class PriorityQueue<TTime> {
|
16 | constructor(capacity: number);
|
17 |
|
18 | length: number;
|
19 |
|
20 | isHigherPriority(left: number, right: number): boolean;
|
21 | percolate(index: number): void;
|
22 | heapify(index: number): void;
|
23 | peek(): ScheduledItem<TTime>;
|
24 | removeAt(index: number): void;
|
25 | dequeue(): ScheduledItem<TTime>;
|
26 | enqueue(item: ScheduledItem<TTime>): void;
|
27 | remove(item: ScheduledItem<TTime>): boolean;
|
28 |
|
29 | static count: number;
|
30 | }
|
31 |
|
32 | class ScheduledItem<TTime> {
|
33 | constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
|
34 |
|
35 | scheduler: IScheduler;
|
36 | state: TTime;
|
37 | action: (scheduler: IScheduler, state: any) => IDisposable;
|
38 | dueTime: TTime;
|
39 | comparer: (x: TTime, y: TTime) => number;
|
40 | disposable: SingleAssignmentDisposable;
|
41 |
|
42 | invoke(): void;
|
43 | compareTo(other: ScheduledItem<TTime>): number;
|
44 | isCancelled(): boolean;
|
45 | invokeCore(): IDisposable;
|
46 | }
|
47 | }
|
48 |
|
49 | namespace config {
|
50 | let Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
|
51 | }
|
52 |
|
53 | namespace helpers {
|
54 | function noop(): void;
|
55 | function notDefined(value: any): boolean;
|
56 | function identity<T>(value: T): T;
|
57 | function defaultNow(): number;
|
58 | function defaultComparer(left: any, right: any): boolean;
|
59 | function defaultSubComparer(left: any, right: any): number;
|
60 | function defaultKeySerializer(key: any): string;
|
61 | function defaultError(err: any): void;
|
62 | function isPromise(p: any): boolean;
|
63 | function asArray<T>(...args: T[]): T[];
|
64 | function not(value: any): boolean;
|
65 | function isFunction(value: any): boolean;
|
66 | }
|
67 |
|
68 | class CompositeDisposable implements IDisposable {
|
69 | constructor(...disposables: IDisposable[]);
|
70 | constructor(disposables: IDisposable[]);
|
71 |
|
72 | isDisposed: boolean;
|
73 | length: number;
|
74 |
|
75 | dispose(): void;
|
76 | add(item: IDisposable): void;
|
77 | remove(item: IDisposable): boolean;
|
78 | toArray(): IDisposable[];
|
79 | }
|
80 |
|
81 | class Disposable implements IDisposable {
|
82 | constructor(action: () => void);
|
83 |
|
84 | static create(action: () => void): IDisposable;
|
85 | static empty: IDisposable;
|
86 |
|
87 | dispose(): void;
|
88 | }
|
89 |
|
90 | // Single assignment
|
91 | class SingleAssignmentDisposable implements IDisposable {
|
92 | constructor();
|
93 |
|
94 | isDisposed: boolean;
|
95 | current: IDisposable;
|
96 |
|
97 | dispose(): void;
|
98 | getDisposable(): IDisposable;
|
99 | setDisposable(value: IDisposable): void;
|
100 | }
|
101 |
|
102 | // SerialDisposable it's an alias of SingleAssignmentDisposable
|
103 | class SerialDisposable extends SingleAssignmentDisposable {
|
104 | constructor();
|
105 | }
|
106 |
|
107 | class RefCountDisposable implements IDisposable {
|
108 | constructor(disposable: IDisposable);
|
109 |
|
110 | dispose(): void;
|
111 |
|
112 | isDisposed: boolean;
|
113 | getDisposable(): IDisposable;
|
114 | }
|
115 |
|
116 | interface IScheduler {
|
117 | now(): number;
|
118 | isScheduler(value: any): boolean;
|
119 |
|
120 | schedule(action: () => void): IDisposable;
|
121 | scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
122 | scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
|
123 | scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
124 | scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
|
125 | scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
|
126 |
|
127 | scheduleRecursive(action: (action: () => void) => void): IDisposable;
|
128 | scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) => void) => void): IDisposable;
|
129 | scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
|
130 | scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
|
131 | scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
|
132 | scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
|
133 |
|
134 | schedulePeriodic(period: number, action: () => void): IDisposable;
|
135 | schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
|
136 | }
|
137 |
|
138 | interface Scheduler extends IScheduler {
|
139 | }
|
140 |
|
141 | interface SchedulerStatic {
|
142 | new (
|
143 | now: () => number,
|
144 | schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
|
145 | scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
|
146 | scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable): Scheduler;
|
147 |
|
148 | normalize(timeSpan: number): number;
|
149 |
|
150 | immediate: IScheduler;
|
151 | currentThread: ICurrentThreadScheduler;
|
152 | default: IScheduler; // alias for Scheduler.timeout
|
153 | timeout: IScheduler;
|
154 | }
|
155 |
|
156 | const Scheduler: SchedulerStatic;
|
157 |
|
158 | // Current Thread IScheduler
|
159 | interface ICurrentThreadScheduler extends IScheduler {
|
160 | scheduleRequired(): boolean;
|
161 | }
|
162 |
|
163 | // Notifications
|
164 | class Notification<T> {
|
165 | accept(observer: IObserver<T>): void;
|
166 | accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
|
167 | toObservable(scheduler?: IScheduler): Observable<T>;
|
168 | hasValue: boolean;
|
169 | equals(other: Notification<T>): boolean;
|
170 | kind: string;
|
171 | value: T;
|
172 | exception: any;
|
173 |
|
174 | static createOnNext<T>(value: T): Notification<T>;
|
175 | static createOnError<T>(exception: any): Notification<T>;
|
176 | static createOnCompleted<T>(): Notification<T>;
|
177 | }
|
178 |
|
179 | // Observer
|
180 | interface IObserver<T> {
|
181 | onNext(value: T): void;
|
182 | onError(exception: any): void;
|
183 | onCompleted(): void;
|
184 | }
|
185 |
|
186 | interface Observer<T> extends IObserver<T> {
|
187 | toNotifier(): (notification: Notification<T>) => void;
|
188 | asObserver(): Observer<T>;
|
189 | }
|
190 |
|
191 | interface ObserverStatic {
|
192 | create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
|
193 | fromNotifier<T>(handler: (notification: Notification<T>, thisArg?: any) => void): Observer<T>;
|
194 | }
|
195 |
|
196 | const Observer: ObserverStatic;
|
197 |
|
198 | interface IObservable<T> {
|
199 | subscribe(observer: Observer<T>): IDisposable;
|
200 | subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
|
201 |
|
202 | subscribeOnNext(onNext: (value: T) => void, thisArg?: any): IDisposable;
|
203 | subscribeOnError(onError: (exception: any) => void, thisArg?: any): IDisposable;
|
204 | subscribeOnCompleted(onCompleted: () => void, thisArg?: any): IDisposable;
|
205 | }
|
206 |
|
207 | interface Observable<T> extends IObservable<T> {
|
208 | forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable; // alias for subscribe
|
209 | toArray(): Observable<T[]>;
|
210 |
|
211 | catch(handler: (exception: Error) => IPromise<T> | Observable<T>): Observable<T>;
|
212 | catch(second: Observable<T>): Observable<T>;
|
213 | catchException(handler: (exception: Error) => IPromise<T> | Observable<T>): Observable<T>; // alias for catch
|
214 | catchException(second: Observable<T>): Observable<T>; // alias for catch
|
215 | combineLatest<T2>(second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
|
216 | combineLatest<T2, TResult>(second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
217 | combineLatest<T2, T3>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
|
218 | combineLatest<T2, T3, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
219 | combineLatest<T2, T3, T4>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
|
220 | combineLatest<T2, T3, T4, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
221 | combineLatest<T2, T3, T4, T5>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
|
222 | combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
223 | combineLatest<TOther, TResult>(souces: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
|
224 | withLatestFrom<T2>(second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
|
225 | withLatestFrom<T2, TResult>(second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
226 | withLatestFrom<T2, T3>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
|
227 | withLatestFrom<T2, T3, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
228 | withLatestFrom<T2, T3, T4>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
|
229 | withLatestFrom<T2, T3, T4, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
230 | withLatestFrom<T2, T3, T4, T5>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
|
231 | withLatestFrom<T2, T3, T4, T5, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
232 | withLatestFrom<TOther, TResult>(souces: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
|
233 | concat(...sources: (Observable<T> | IPromise<T>)[]): Observable<T>;
|
234 | concat(sources: (Observable<T> | IPromise<T>)[]): Observable<T>;
|
235 | concatAll(): T;
|
236 | concatObservable(): Observable<T>; // alias for concatAll
|
237 | concatMap<T2, R>(selector: (value: T, index: number) => Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>; // alias for selectConcat
|
238 | concatMap<T2, R>(selector: (value: T, index: number) => IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>; // alias for selectConcat
|
239 | concatMap<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>; // alias for selectConcat
|
240 | concatMap<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>; // alias for selectConcat
|
241 | concatMap<R>(selector: (value: T, index: number) => R[]): Observable<R>; // alias for selectConcat
|
242 | concatMap<R>(sequence: Observable<R>): Observable<R>; // alias for selectConcat
|
243 | concatMap<R>(sequence: R[]): Observable<R>; // alias for selectConcat
|
244 | merge(maxConcurrent: number): T;
|
245 | merge(other: Observable<T>): Observable<T>;
|
246 | merge(other: IPromise<T>): Observable<T>;
|
247 | mergeAll(): T;
|
248 | mergeObservable(): T; // alias for mergeAll
|
249 | skipUntil<T2>(other: Observable<T2>): Observable<T>;
|
250 | skipUntil<T2>(other: IPromise<T2>): Observable<T>;
|
251 | switch(): T;
|
252 | switchLatest(): T; // alias for switch
|
253 | takeUntil<T2>(other: Observable<T2>): Observable<T>;
|
254 | takeUntil<T2>(other: IPromise<T2>): Observable<T>;
|
255 | zip<T2>(second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
|
256 | zip<T2, TResult>(second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
257 | zip<T2, T3>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
|
258 | zip<T2, T3, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
259 | zip<T2, T3, T4>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
|
260 | zip<T2, T3, T4, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
261 | zip<T2, T3, T4, T5>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
|
262 | zip<T2, T3, T4, T5, TResult>(second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
263 | zip<TOther, TResult>(second: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
|
264 |
|
265 | asObservable(): Observable<T>;
|
266 | dematerialize<TOrigin>(): Observable<TOrigin>;
|
267 | distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
|
268 | distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
|
269 | do(observer: Observer<T>): Observable<T>;
|
270 | do(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>;
|
271 | doAction(observer: Observer<T>): Observable<T>; // alias for do
|
272 | doAction(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>; // alias for do
|
273 | tap(observer: Observer<T>): Observable<T>; // alias for do
|
274 | tap(onNext?: (value: T) => void, onError?: (exception: Error) => void, onCompleted?: () => void): Observable<T>; // alias for do
|
275 |
|
276 | doOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
|
277 | doOnError(onError: (exception: any) => void, thisArg?: any): Observable<T>;
|
278 | doOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
|
279 | tapOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
|
280 | tapOnError(onError: (exception: any) => void, thisArg?: any): Observable<T>;
|
281 | tapOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
|
282 |
|
283 | finally(action: () => void): Observable<T>;
|
284 | finallyAction(action: () => void): Observable<T>; // alias for finally
|
285 | ignoreElements(): Observable<T>;
|
286 | materialize(): Observable<Notification<T>>;
|
287 | repeat(repeatCount?: number): Observable<T>;
|
288 | retry(retryCount?: number): Observable<T>;
|
289 | retryWhen<TError>(notifier: (errors: Observable<TError>) => Observable<any>): Observable<T>;
|
290 |
|
291 | /**
|
292 | * Applies an accumulator function over an observable sequence and returns each intermediate result. The optional seed value is used as the initial accumulator value.
|
293 | * For aggregation behavior with no intermediate results, see Observable.aggregate.
|
294 | * @example
|
295 | * var res = source.scan(function (acc, x) { return acc + x; });
|
296 | * var res = source.scan(function (acc, x) { return acc + x; }, 0);
|
297 | * @param accumulator An accumulator function to be invoked on each element.
|
298 | * @param seed The initial accumulator value.
|
299 | * @returns An observable sequence containing the accumulated values.
|
300 | */
|
301 | scan<TAcc>(accumulator: (acc: TAcc, value: T, index?: number, source?: Observable<TAcc>) => TAcc, seed: TAcc): Observable<TAcc>;
|
302 | scan(accumulator: (acc: T, value: T, index?: number, source?: Observable<T>) => T): Observable<T>;
|
303 |
|
304 | skipLast(count: number): Observable<T>;
|
305 | startWith(...values: T[]): Observable<T>;
|
306 | startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
|
307 | takeLast(count: number): Observable<T>;
|
308 | takeLastBuffer(count: number): Observable<T[]>;
|
309 |
|
310 | select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
|
311 | map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>; // alias for select
|
312 | pluck<TResult>(prop: string): Observable<TResult>;
|
313 | selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
|
314 | selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
|
315 | selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
|
316 | selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
|
317 | selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
|
318 | selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
|
319 | selectMany<TResult>(selector: (value: T) => TResult[]): Observable<TResult>; // alias for selectMany
|
320 | flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>; // alias for selectMany
|
321 | flatMap<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>; // alias for selectMany
|
322 | flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>; // alias for selectMany
|
323 | flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>; // alias for selectMany
|
324 | flatMap<TResult>(other: Observable<TResult>): Observable<TResult>; // alias for selectMany
|
325 | flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>; // alias for selectMany
|
326 | flatMap<TResult>(selector: (value: T) => TResult[]): Observable<TResult>; // alias for selectMany
|
327 |
|
328 | /**
|
329 | * Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
|
330 | * @param onNext A transform function to apply to each element; the second parameter of the function represents the index of the source element.
|
331 | * @param onError A transform function to apply when an error occurs in the source sequence.
|
332 | * @param onCompleted A transform function to apply when the end of the source sequence is reached.
|
333 | * @param [thisArg] An optional "this" to use to invoke each transform.
|
334 | * @returns An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.
|
335 | */
|
336 | selectManyObserver<T2, T3, T4>(onNext: (value: T, index: number) => Observable<T2>, onError: (exception: any) => Observable<T3>, onCompleted: () => Observable<T4>, thisArg?: any): Observable<T2 | T3 | T4>;
|
337 |
|
338 | /**
|
339 | * Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
|
340 | * @param onNext A transform function to apply to each element; the second parameter of the function represents the index of the source element.
|
341 | * @param onError A transform function to apply when an error occurs in the source sequence.
|
342 | * @param onCompleted A transform function to apply when the end of the source sequence is reached.
|
343 | * @param [thisArg] An optional "this" to use to invoke each transform.
|
344 | * @returns An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.
|
345 | */
|
346 | flatMapObserver<T2, T3, T4>(onNext: (value: T, index: number) => Observable<T2>, onError: (exception: any) => Observable<T3>, onCompleted: () => Observable<T4>, thisArg?: any): Observable<T2 | T3 | T4>;
|
347 |
|
348 | selectConcat<T2, R>(selector: (value: T, index: number) => Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;
|
349 | selectConcat<T2, R>(selector: (value: T, index: number) => IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;
|
350 | selectConcat<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>;
|
351 | selectConcat<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;
|
352 | selectConcat<R>(sequence: Observable<R>): Observable<R>;
|
353 |
|
354 | /**
|
355 | * Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then
|
356 | * transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
|
357 | * @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
|
358 | * @param [thisArg] Object to use as this when executing callback.
|
359 | * @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences
|
360 | * and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
|
361 | */
|
362 | selectSwitch<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>;
|
363 | /**
|
364 | * Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then
|
365 | * transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
|
366 | * @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
|
367 | * @param [thisArg] Object to use as this when executing callback.
|
368 | * @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences
|
369 | * and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
|
370 | */
|
371 | flatMapLatest<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>; // alias for selectSwitch
|
372 | /**
|
373 | * Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then
|
374 | * transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
|
375 | * @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
|
376 | * @param [thisArg] Object to use as this when executing callback.
|
377 | * @since 2.2.28
|
378 | * @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences
|
379 | * and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
|
380 | */
|
381 | switchMap<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>; // alias for selectSwitch
|
382 |
|
383 | skip(count: number): Observable<T>;
|
384 | skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
|
385 | take(count: number, scheduler?: IScheduler): Observable<T>;
|
386 | takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
|
387 | where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
|
388 | filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
|
389 |
|
390 | /**
|
391 | * Converts an existing observable sequence to an ES6 Compatible Promise
|
392 | * @example
|
393 | * var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
|
394 | * @param promiseCtor The constructor of the promise.
|
395 | * @returns An ES6 compatible promise with the last value from the observable sequence.
|
396 | */
|
397 | toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
|
398 | /**
|
399 | * Converts an existing observable sequence to an ES6 Compatible Promise
|
400 | * @example
|
401 | * var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
|
402 | *
|
403 | * // With config
|
404 | * Rx.config.Promise = RSVP.Promise;
|
405 | * var promise = Rx.Observable.return(42).toPromise();
|
406 | * @param [promiseCtor] The constructor of the promise. If not provided, it looks for it in Rx.config.Promise.
|
407 | * @returns An ES6 compatible promise with the last value from the observable sequence.
|
408 | */
|
409 | toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
|
410 |
|
411 | // Experimental Flattening
|
412 |
|
413 | /**
|
414 | * Performs a exclusive waiting for the first to finish before subscribing to another observable.
|
415 | * Observables that come in between subscriptions will be dropped on the floor.
|
416 | * Can be applied on `Observable<Observable<R>>` or `Observable<IPromise<R>>`.
|
417 | * @since 2.2.28
|
418 | * @returns A exclusive observable with only the results that happen when subscribed.
|
419 | */
|
420 | exclusive<R>(): Observable<R>;
|
421 |
|
422 | /**
|
423 | * Performs a exclusive map waiting for the first to finish before subscribing to another observable.
|
424 | * Observables that come in between subscriptions will be dropped on the floor.
|
425 | * Can be applied on `Observable<Observable<I>>` or `Observable<IPromise<I>>`.
|
426 | * @since 2.2.28
|
427 | * @param selector Selector to invoke for every item in the current subscription.
|
428 | * @param [thisArg] An optional context to invoke with the selector parameter.
|
429 | * @returns An exclusive observable with only the results that happen when subscribed.
|
430 | */
|
431 | exclusiveMap<I, R>(selector: (value: I, index: number, source: Observable<I>) => R, thisArg?: any): Observable<R>;
|
432 |
|
433 | publish(): ConnectableObservable<T>;
|
434 | }
|
435 |
|
436 | interface ConnectableObservable<T> extends Observable<T> {
|
437 | connect(): Disposable;
|
438 | }
|
439 |
|
440 | interface ObservableStatic {
|
441 | create<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
|
442 | create<T>(subscribe: (observer: Observer<T>) => () => void): Observable<T>;
|
443 | create<T>(subscribe: (observer: Observer<T>) => void): Observable<T>;
|
444 | createWithDisposable<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
|
445 | defer<T>(observableFactory: () => Observable<T>): Observable<T>;
|
446 | defer<T>(observableFactory: () => IPromise<T>): Observable<T>;
|
447 | empty<T>(scheduler?: IScheduler): Observable<T>;
|
448 |
|
449 | /**
|
450 | * This method creates a new Observable sequence from an array object.
|
451 | * @param array An array-like or iterable object to convert to an Observable sequence.
|
452 | * @param mapFn Map function to call on every element of the array.
|
453 | * @param [thisArg] The context to use calling the mapFn if provided.
|
454 | * @param [scheduler] Optional scheduler to use for scheduling. If not provided, defaults to Scheduler.currentThread.
|
455 | */
|
456 | from<T, TResult>(array: T[], mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler): Observable<TResult>;
|
457 | /**
|
458 | * This method creates a new Observable sequence from an array object.
|
459 | * @param array An array-like or iterable object to convert to an Observable sequence.
|
460 | * @param [mapFn] Map function to call on every element of the array.
|
461 | * @param [thisArg] The context to use calling the mapFn if provided.
|
462 | * @param [scheduler] Optional scheduler to use for scheduling. If not provided, defaults to Scheduler.currentThread.
|
463 | */
|
464 | from<T>(array: T[], mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
|
465 |
|
466 | /**
|
467 | * This method creates a new Observable sequence from an array-like object.
|
468 | * @param array An array-like or iterable object to convert to an Observable sequence.
|
469 | * @param mapFn Map function to call on every element of the array.
|
470 | * @param [thisArg] The context to use calling the mapFn if provided.
|
471 | * @param [scheduler] Optional scheduler to use for scheduling. If not provided, defaults to Scheduler.currentThread.
|
472 | */
|
473 | from<T, TResult>(array: { length: number; [index: number]: T; }, mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler): Observable<TResult>;
|
474 | /**
|
475 | * This method creates a new Observable sequence from an array-like object.
|
476 | * @param array An array-like or iterable object to convert to an Observable sequence.
|
477 | * @param [mapFn] Map function to call on every element of the array.
|
478 | * @param [thisArg] The context to use calling the mapFn if provided.
|
479 | * @param [scheduler] Optional scheduler to use for scheduling. If not provided, defaults to Scheduler.currentThread.
|
480 | */
|
481 | from<T>(array: { length: number; [index: number]: T; }, mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
|
482 |
|
483 | /**
|
484 | * This method creates a new Observable sequence from an array-like or iterable object.
|
485 | * @param array An array-like or iterable object to convert to an Observable sequence.
|
486 | * @param [mapFn] Map function to call on every element of the array.
|
487 | * @param [thisArg] The context to use calling the mapFn if provided.
|
488 | * @param [scheduler] Optional scheduler to use for scheduling. If not provided, defaults to Scheduler.currentThread.
|
489 | */
|
490 | from<T>(iterable: any, mapFn?: (value: any, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
|
491 |
|
492 | fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
|
493 | fromArray<T>(array: { length: number; [index: number]: T; }, scheduler?: IScheduler): Observable<T>;
|
494 |
|
495 | generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable<TResult>;
|
496 | never<T>(): Observable<T>;
|
497 |
|
498 | /**
|
499 | * This method creates a new Observable instance with a variable number of arguments, regardless of number or type of the arguments.
|
500 | *
|
501 | * @example
|
502 | * var res = Rx.Observable.of(1, 2, 3);
|
503 | * @since 2.2.28
|
504 | * @returns The observable sequence whose elements are pulled from the given arguments.
|
505 | */
|
506 | of<T>(...values: T[]): Observable<T>;
|
507 |
|
508 | /**
|
509 | * This method creates a new Observable instance with a variable number of arguments, regardless of number or type of the arguments.
|
510 | * @example
|
511 | * var res = Rx.Observable.ofWithScheduler(Rx.Scheduler.timeout, 1, 2, 3);
|
512 | * @since 2.2.28
|
513 | * @param [scheduler] A scheduler to use for scheduling the arguments.
|
514 | * @returns The observable sequence whose elements are pulled from the given arguments.
|
515 | */
|
516 | ofWithScheduler<T>(scheduler?: IScheduler, ...values: T[]): Observable<T>;
|
517 | range(start: number, count: number, scheduler?: IScheduler): Observable<number>;
|
518 | repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): Observable<T>;
|
519 | return<T>(value: T, scheduler?: IScheduler): Observable<T>;
|
520 | /**
|
521 | * @since 2.2.28
|
522 | */
|
523 | just<T>(value: T, scheduler?: IScheduler): Observable<T>; // alias for return
|
524 | returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>; // alias for return
|
525 | throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
|
526 | throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
|
527 | throwError<T>(error: Error, scheduler?: IScheduler): Observable<T>; // alias for throw
|
528 |
|
529 | catch<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>;
|
530 | catch<T>(...sources: Observable<T>[]): Observable<T>;
|
531 | catch<T>(...sources: IPromise<T>[]): Observable<T>;
|
532 | catchException<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>; // alias for catch
|
533 | catchException<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
|
534 | catchException<T>(...sources: IPromise<T>[]): Observable<T>; // alias for catch
|
535 | catchError<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>; // alias for catch
|
536 | catchError<T>(...sources: Observable<T>[]): Observable<T>; // alias for catch
|
537 | catchError<T>(...sources: IPromise<T>[]): Observable<T>; // alias for catch
|
538 |
|
539 | combineLatest<T, T2>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
|
540 | combineLatest<T, T2, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
541 | combineLatest<T, T2, T3>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
|
542 | combineLatest<T, T2, T3, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
543 | combineLatest<T, T2, T3, T4>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
|
544 | combineLatest<T, T2, T3, T4, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
545 | combineLatest<T, T2, T3, T4, T5>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
|
546 | combineLatest<T, T2, T3, T4, T5, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
547 | combineLatest<T>(sources: (Observable<T> | IPromise<T>)[]): Observable<T[]>;
|
548 | combineLatest<TOther, TResult>(sources: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
|
549 |
|
550 | withLatestFrom<T, T2>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>): Observable<[T, T2]>;
|
551 | withLatestFrom<T, T2, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
|
552 | withLatestFrom<T, T2, T3>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>): Observable<[T, T2, T3]>;
|
553 | withLatestFrom<T, T2, T3, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
|
554 | withLatestFrom<T, T2, T3, T4>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>): Observable<[T, T2, T3, T4]>;
|
555 | withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
|
556 | withLatestFrom<T, T2, T3, T4, T5>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>): Observable<[T, T2, T3, T4, T5]>;
|
557 | withLatestFrom<T, T2, T3, T4, T5, TResult>(first: Observable<T> | IPromise<T>, second: Observable<T2> | IPromise<T2>, third: Observable<T3> | IPromise<T3>, fourth: Observable<T4> | IPromise<T4>, fifth: Observable<T5> | IPromise<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
|
558 | withLatestFrom<TOther, TResult>(souces: (Observable<TOther> | IPromise<TOther>)[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
|
559 |
|
560 | concat<T>(...sources: Observable<T>[]): Observable<T>;
|
561 | concat<T>(...sources: IPromise<T>[]): Observable<T>;
|
562 | concat<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>;
|
563 | merge<T>(...sources: Observable<T>[]): Observable<T>;
|
564 | merge<T>(...sources: IPromise<T>[]): Observable<T>;
|
565 | merge<T>(sources: IPromise<T>[] | Observable<T>[]): Observable<T>;
|
566 | merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
|
567 | merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
|
568 | merge<T>(scheduler: IScheduler, sources: IPromise<T>[] | Observable<T>[]): Observable<T>;
|
569 |
|
570 | pairs<T>(obj: { [key: string]: T }, scheduler?: IScheduler): Observable<[string, T]>;
|
571 |
|
572 | zip<T1, T2>(first: Observable<T1> | IPromise<T1>, sources: Observable<T2> | IPromise<T2> | (Observable<T2> | IPromise<T2>)[]): Observable<[T1, T2]>;
|
573 | zip<T1, T2, TResult>(first: Observable<T1> | IPromise<T1>, sources: (Observable<T2> | IPromise<T2>)[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
|
574 | zip<T1, T2, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
|
575 | zip<T1, T2, T3>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>): Observable<[T1, T2, T3]>;
|
576 | zip<T1, T2, T3, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
|
577 | zip<T1, T2, T3, T4>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>): Observable<[T1, T2, T3, T4]>;
|
578 | zip<T1, T2, T3, T4, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
|
579 | zip<T1, T2, T3, T4, T5>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>, source5: Observable<T5> | IPromise<T5>): Observable<[T1, T2, T3, T4, T5]>;
|
580 | zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1> | IPromise<T1>, source2: Observable<T2> | IPromise<T2>, source3: Observable<T3> | IPromise<T3>, source4: Observable<T4> | IPromise<T4>, source5: Observable<T5> | IPromise<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
|
581 | zipArray<T>(...sources: (Observable<T> | IPromise<T>)[]): Observable<T[]>;
|
582 | zipArray<T>(sources: (Observable<T> | IPromise<T>)[]): Observable<T[]>;
|
583 |
|
584 | /**
|
585 | * Converts a Promise to an Observable sequence
|
586 | * @param promise An ES6 Compliant promise.
|
587 | * @returns An Observable sequence which wraps the existing promise success and failure.
|
588 | */
|
589 | fromPromise<T>(promise: IPromise<T>): Observable<T>;
|
590 |
|
591 | prototype: any;
|
592 | }
|
593 |
|
594 | const Observable: ObservableStatic;
|
595 | }
|
596 |
|
597 | // Async
|
598 |
|
599 | declare namespace Rx {
|
600 | namespace config {
|
601 | /**
|
602 | * Configuration option to determine whether to use native events only
|
603 | */
|
604 | const useNativeEvents: boolean;
|
605 | }
|
606 |
|
607 | interface ObservableStatic {
|
608 | fromCallback: {
|
609 | // with single result callback without selector
|
610 | <TResult>(func: (callback: (result: TResult) => any) => any, context?: any): () => Observable<TResult>;
|
611 | <T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, context?: any): (arg1: T1) => Observable<TResult>;
|
612 | <T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
|
613 | <T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
|
614 |
|
615 | <TCallbackResult, TResult>(func: (callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
|
616 | <T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
|
617 | <T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
|
618 | <T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
|
619 |
|
620 | <TResult>(func: (callback: Function) => any, context?: any): () => Observable<TResult>;
|
621 | <T1, TResult>(func: (arg1: T1, callback: Function) => any, context?: any): (arg1: T1) => Observable<TResult>;
|
622 | <T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
|
623 | <T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
|
624 |
|
625 | <TCallbackResult, TResult>(func: Function, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
|
626 |
|
627 | <TResult>(func: Function, context?: any): (...args: any[]) => Observable<TResult>;
|
628 | };
|
629 |
|
630 | fromNodeCallback: {
|
631 |
|
632 | <T>(func: (callback: (err: any, result: T) => any) => any, context?: any): () => Observable<T>;
|
633 | <T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1) => Observable<T>;
|
634 | <T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
|
635 | <T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
|
636 |
|
637 | <TC, TR>(func: (callback: Function) => any, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
|
638 | <T1, TC, TR>(func: (arg1: T1, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
|
639 | <T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
|
640 | <T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
|
641 |
|
642 | <TR>(func: (callback: Function) => any, context?: any): () => Observable<TR>;
|
643 | <T1, TR>(func: (arg1: T1, callback: Function) => any, context?: any): (arg1: T1) => Observable<TR>;
|
644 | <T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
|
645 | <T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
|
646 |
|
647 | <TC, T>(func: Function, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
|
648 |
|
649 | <T>(func: Function, context?: any): (...args: any[]) => Observable<T>;
|
650 | };
|
651 |
|
652 | fromEvent<T>(element: ArrayLike<DOMEventTarget> | DOMEventTarget | NodeEventTarget| NativeEventTarget, eventName: string, selector?: (...args: any[]) => T): Observable<T>;
|
653 |
|
654 | fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (...args: any[]) => T): Observable<T>;
|
655 | }
|
656 |
|
657 | interface NodeEventTarget {
|
658 | addListener(name: string, cb: (e: any) => any): void;
|
659 | }
|
660 |
|
661 | interface NativeEventTarget {
|
662 | on(name: string, cb: (e: any) => any): void;
|
663 | off(name: string, cb: (e: any) => any): void;
|
664 | }
|
665 |
|
666 | interface DOMEventTarget {
|
667 | addEventListener(type: string, listener: (e: any) => any, useCapture: boolean): void;
|
668 | removeEventListener(type: string, listener: (e: any) => any, useCapture: boolean): void;
|
669 | }
|
670 | }
|
671 |
|
672 | // time
|
673 |
|
674 | declare namespace Rx {
|
675 | interface TimeInterval<T> {
|
676 | value: T;
|
677 | interval: number;
|
678 | }
|
679 |
|
680 | interface Timestamp<T> {
|
681 | value: T;
|
682 | timestamp: number;
|
683 | }
|
684 |
|
685 | interface Observable<T> {
|
686 | delay(dueTime: Date, scheduler?: IScheduler): Observable<T>;
|
687 | delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
|
688 |
|
689 | debounce(dueTime: number, scheduler?: IScheduler): Observable<T>;
|
690 | throttleWithTimeout(dueTime: number, scheduler?: IScheduler): Observable<T>;
|
691 | /**
|
692 | * @deprecated use #debounce or #throttleWithTimeout instead.
|
693 | */
|
694 | throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
|
695 |
|
696 | timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
|
697 |
|
698 | timestamp(scheduler?: IScheduler): Observable<Timestamp<T>>;
|
699 |
|
700 | sample(interval: number, scheduler?: IScheduler): Observable<T>;
|
701 | sample<TSample>(sampler: Observable<TSample>, scheduler?: IScheduler): Observable<T>;
|
702 |
|
703 | timeout(dueTime: Date, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
|
704 | timeout(dueTime: number, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
|
705 | }
|
706 |
|
707 | interface ObservableStatic {
|
708 | interval(period: number, scheduler?: IScheduler): Observable<number>;
|
709 | interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
|
710 | timer(dueTime: number, period: number, scheduler?: IScheduler): Observable<number>;
|
711 | timer(dueTime: number, scheduler?: IScheduler): Observable<number>;
|
712 | }
|
713 | }
|
714 |
|
715 | declare module "rx-lite" {
|
716 | export = Rx;
|
717 | }
|
718 |
|
\ | No newline at end of file |