From de65cd05cb952591da261eeb504ab09516a67616 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 14 Apr 2014 10:47:37 +0400
Subject: [PATCH 1/6] Updated rx.d.ts and rx-lite.d.ts to version 2.2.20

---
 rx.js/rx-lite.d.ts | 76 ++++++++++++++++++++++++++++++++++++++++++++--
 rx.js/rx.d.ts      |  8 ++++-
 2 files changed, 81 insertions(+), 3 deletions(-)

diff --git a/rx.js/rx-lite.d.ts b/rx.js/rx-lite.d.ts
index c0a27c3c4..15767ac61 100644
--- a/rx.js/rx-lite.d.ts
+++ b/rx.js/rx-lite.d.ts
@@ -201,13 +201,27 @@ declare module Rx {
 
 		catch(handler: (exception: any) => Observable<T>): Observable<T>;
 		catchException(handler: (exception: any) => Observable<T>): Observable<T>;	// alias for catch
+		catch(handler: (exception: any) => IPromise<T>): Observable<T>;
+		catchException(handler: (exception: any) => IPromise<T>): Observable<T>;	// alias for catch
 		catch(second: Observable<T>): Observable<T>;
 		catchException(second: Observable<T>): Observable<T>;	// alias for catch
 		combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T2, TResult>(second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
 		combineLatest<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
 		combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, T4, TResult>(second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
 		combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
 		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
+		combineLatest<TOther, TResult>(souces: IPromise<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
 		concat(...sources: Observable<T>[]): Observable<T>;
 		concat(...sources: IPromise<T>[]): Observable<T>;
 		concat(sources: Observable<T>[]): Observable<T>;
@@ -224,10 +238,22 @@ declare module Rx {
 		switchLatest(): T;	// alias for switch
 		takeUntil<T2>(other: Observable<T2>): Observable<T>;
 		zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		zip<T2, TResult>(second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
 		zip<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		zip<T2, T3, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		zip<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		zip<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
 		zip<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<T2, T3, T4, TResult>(second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
 		zip<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
-		zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, right: Observable<TOther>) => TResult): Observable<TResult>;
+		zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
+		zip<TOther, TResult>(second: IPromise<TOther>[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
 
 		asObservable(): Observable<T>;
 		dematerialize<TOrigin>(): Observable<TOrigin>;
@@ -368,6 +394,39 @@ declare module Rx {
 		catch<T>(...sources: IPromise<T>[]): Observable<T>;
 		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
 		catchException<T>(...sources: IPromise<T>[]): Observable<T>;	// alias for catch
+
+		combineLatest<T, T2, TResult>(first: Observable<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T, T2, TResult>(first: IPromise<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T, T2, TResult>(first: Observable<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T, T2, TResult>(first: IPromise<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, T4, T5, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
+		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+		combineLatest<TOther, TResult>(souces: IPromise<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+
 		concat<T>(...sources: Observable<T>[]): Observable<T>;
 		concat<T>(...sources: IPromise<T>[]): Observable<T>;
 		concat<T>(sources: Observable<T>[]): Observable<T>;
@@ -380,10 +439,23 @@ declare module Rx {
 		merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
 		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
 		merge<T>(scheduler: IScheduler, sources: IPromise<T>[]): Observable<T>;
-		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<T2>) => TResult): Observable<TResult>;
+
+		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(first: Observable<T1>, sources: IPromise<T2>[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
 		zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(source1: Observable<T1>, source2: IPromise<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
 		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
 		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
 		zip<T1, T2, T3, T4, T5, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: Observable<T4>, source5: Observable<T5>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable<TResult>;
 		zipArray<T>(...sources: Observable<T>[]): Observable<T[]>;
 		zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index 597264fa8..1a5d775a5 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS v2.2.18
+// Type definitions for RxJS v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
@@ -66,7 +66,9 @@ declare module Rx {
 		subscribeOn(scheduler: IScheduler): Observable<T>;
 
 		amb(rightSource: Observable<T>): Observable<T>;
+		amb(rightSource: IPromise<T>): Observable<T>;
 		onErrorResumeNext(second: Observable<T>): Observable<T>;
+		onErrorResumeNext(second: IPromise<T>): Observable<T>;
 		bufferWithCount(count: number, skip?: number): Observable<T[]>;
 		windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
 		defaultIfEmpty(defaultValue?: T): Observable<T>;
@@ -81,9 +83,13 @@ declare module Rx {
 	interface ObservableStatic {
 		using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
 		amb<T>(...sources: Observable<T>[]): Observable<T>;
+		amb<T>(...sources: IPromise<T>[]): Observable<T>;
 		amb<T>(sources: Observable<T>[]): Observable<T>;
+		amb<T>(sources: IPromise<T>[]): Observable<T>;
 		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
+		onErrorResumeNext<T>(...sources: IPromise<T>[]): Observable<T>;
 		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
+		onErrorResumeNext<T>(sources: IPromise<T>[]): Observable<T>;
 	}
 
 	interface GroupedObservable<TKey, TElement> extends Observable<TElement> {

From 27d981af6346c4059d3a57917e92ecc8bef694f8 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 14 Apr 2014 10:51:24 +0400
Subject: [PATCH 2/6] Updated rx.aggregates.d.ts t oversion 2.2.20

---
 rx.js/rx.aggregates.d.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rx.js/rx.aggregates.d.ts b/rx.js/rx.aggregates.d.ts
index 4ba03b4c6..ea5cca99b 100644
--- a/rx.js/rx.aggregates.d.ts
+++ b/rx.js/rx.aggregates.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Aggregates package
+// Type definitions for RxJS-Aggregates v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
@@ -33,7 +33,9 @@ declare module Rx {
 		average(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
 
 		sequenceEqual<TOther>(second: Observable<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		sequenceEqual<TOther>(second: IPromise<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
 		sequenceEqual(second: Observable<T>): Observable<boolean>;
+		sequenceEqual(second: IPromise<T>): Observable<boolean>;
 		sequenceEqual<TOther>(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
 		sequenceEqual(second: T[]): Observable<boolean>;
 

From 52d7857dad794b7892d7ae7a607a4abc7f781d6d Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 14 Apr 2014 10:54:32 +0400
Subject: [PATCH 3/6] Updated rx.async.d.ts to version 2.2.20

---
 rx.js/rx.async.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index 522b87c0d..9a03bb33b 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Async v2.2.18
+// Type definitions for RxJS-Async v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: zoetrope <https://github.com/zoetrope>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>

From 71b823a0e348978df67f9f88137141f53d0c43d6 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 14 Apr 2014 11:12:45 +0400
Subject: [PATCH 4/6] Updated RxJS-BackPressure to v2.2.20

---
 rx.js/rx.backpressure-lite.d.ts | 8 +++++++-
 rx.js/rx.backpressure.d.ts      | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/rx.js/rx.backpressure-lite.d.ts b/rx.js/rx.backpressure-lite.d.ts
index 3cc78f6ca..420a568f3 100644
--- a/rx.js/rx.backpressure-lite.d.ts
+++ b/rx.js/rx.backpressure-lite.d.ts
@@ -14,6 +14,7 @@ declare module Rx {
 		* @returns The observable sequence which is paused based upon the pauser.
 		*/
 		pausable(pauser: Observable<boolean>): Observable<T>;
+		pausable(pauser?: ISubject<boolean>): PausableObservable<T>;
 
 		/**
 		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
@@ -24,7 +25,7 @@ declare module Rx {
 		* @param pauser The observable sequence used to pause the underlying sequence.
 		* @returns The observable sequence which is paused based upon the pauser.
 		*/
-		pausableBuffered(pauser: Observable<boolean>): Observable<T>;
+		pausableBuffered(pauser?: ISubject<boolean>): PausableObservable<T>;
 
 		/**
 		* Attaches a controller to the observable sequence with the ability to queue.
@@ -38,4 +39,9 @@ declare module Rx {
 	export interface ControlledObservable<T> extends Observable<T> {
 		request(numberOfItems?: number): IDisposable;
 	}
+
+	export interface PausableObservable<T> extends Observable<T> {
+		pause(): void;
+		resume(): void;
+	}
 }
diff --git a/rx.js/rx.backpressure.d.ts b/rx.js/rx.backpressure.d.ts
index 4108ba410..5ec8c3f91 100644
--- a/rx.js/rx.backpressure.d.ts
+++ b/rx.js/rx.backpressure.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-BackPressure v2.2.18
+// Type definitions for RxJS-BackPressure v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

From aca5a09c70f05c4409b55a8ff132dc83b4052fa7 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 14 Apr 2014 11:27:10 +0400
Subject: [PATCH 5/6] Updated RxJS-Experimental to v2.2.20

---
 rx.js/rx.experimental.d.ts | 61 ++++++++++++++++++++++++++++----------
 1 file changed, 45 insertions(+), 16 deletions(-)

diff --git a/rx.js/rx.experimental.d.ts b/rx.js/rx.experimental.d.ts
index db23df3fd..1b9259944 100644
--- a/rx.js/rx.experimental.d.ts
+++ b/rx.js/rx.experimental.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS/Experimental
+// Type definitions for RxJS-Experimental v2.2.20
 // Project: https://github.com/Reactive-Extensions/RxJS/
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -45,11 +45,12 @@ declare module Rx {
 		/**
 		 *  Runs two observable sequences in parallel and combines their last elemenets.
 		 *
-		 * @param second Second observable sequence.
+		 * @param second Second observable sequence or promise.
 		 * @param resultSelector Result selector function to invoke with the last elements of both sequences.
 		 * @returns An observable sequence with the result of calling the selector function with the last elements of both input sequences.
 		 */
 		forkJoin<TSecond, TResult>(second: Observable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
+		forkJoin<TSecond, TResult>(second: IPromise<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
 
 		/**
 		 * Comonadic bind operator.
@@ -67,11 +68,14 @@ declare module Rx {
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, obs2);
 		 * @param condition The condition which determines if the thenSource or elseSource will be run.
-		 * @param thenSource The observable sequence that will be run if the condition function returns true.
-		 * @param elseSource The observable sequence that will be run if the condition function returns false.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
+		 * @param elseSource The observable sequence or promise that will be run if the condition function returns false.
 		 * @returns An observable sequence which is either the thenSource or elseSource.
 		 */
 		if<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: IPromise<T>): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: Observable<T>): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
@@ -79,11 +83,12 @@ declare module Rx {
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, scheduler);
 		 * @param condition The condition which determines if the thenSource or empty sequence will be run.
-		 * @param thenSource The observable sequence that will be run if the condition function returns true.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
 		 * @param scheduler Scheduler used to create Rx.Observabe.Empty.
 		 * @returns An observable sequence which is either the thenSource or empty sequence.
 		 */
 		if<T>(condition: () => boolean, thenSource: Observable<T>, scheduler?: IScheduler): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: IPromise<T>, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
@@ -91,11 +96,14 @@ declare module Rx {
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, obs2);
 		 * @param condition The condition which determines if the thenSource or elseSource will be run.
-		 * @param thenSource The observable sequence that will be run if the condition function returns true.
-		 * @param elseSource The observable sequence that will be run if the condition function returns false.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
+		 * @param elseSource The observable sequence or promise that will be run if the condition function returns false.
 		 * @returns An observable sequence which is either the thenSource or elseSource.
 		 */
 		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: IPromise<T>): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: Observable<T>): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
@@ -103,11 +111,12 @@ declare module Rx {
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, scheduler);
 		 * @param condition The condition which determines if the thenSource or empty sequence will be run.
-		 * @param thenSource The observable sequence that will be run if the condition function returns true.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
 		 * @param scheduler Scheduler used to create Rx.Observabe.Empty.
 		 * @returns An observable sequence which is either the thenSource or empty sequence.
 		 */
 		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, scheduler?: IScheduler): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Concatenates the observable sequences obtained by running the specified result selector for each element in source.
@@ -131,19 +140,21 @@ declare module Rx {
 		 *  Repeats source as long as condition holds emulating a while loop.
 		 * There is an alias for this method called 'whileDo' for browsers <IE9
 		 * @param condition The condition which determines if the source will be repeated.
-		 * @param source The observable sequence that will be run if the condition function returns true.
+		 * @param source The observable sequence or promise that will be run if the condition function returns true.
 		 * @returns An observable sequence which is repeated as long as the condition holds.  
 		 */
 		while<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
+		while<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Repeats source as long as condition holds emulating a while loop.
 		 * There is an alias for this method called 'whileDo' for browsers <IE9
 		 * @param condition The condition which determines if the source will be repeated.
-		 * @param source The observable sequence that will be run if the condition function returns true.
+		 * @param source The observable sequence or promise that will be run if the condition function returns true.
 		 * @returns An observable sequence which is repeated as long as the condition holds.  
 		 */
 		whileDo<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
+		whileDo<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -153,11 +164,14 @@ declare module Rx {
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
-		 * @param elseSource The observable sequence that will be run if the sources are not matched.
+		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -174,6 +188,7 @@ declare module Rx {
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -183,11 +198,14 @@ declare module Rx {
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
-		 * @param elseSource The observable sequence that will be run if the sources are not matched.
+		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -204,6 +222,7 @@ declare module Rx {
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -213,11 +232,14 @@ declare module Rx {
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
-		 * @param elseSource The observable sequence that will be run if the sources are not matched.
+		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -234,6 +256,7 @@ declare module Rx {
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -243,11 +266,14 @@ declare module Rx {
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
-		 * @param elseSource The observable sequence that will be run if the sources are not matched.
+		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -264,25 +290,28 @@ declare module Rx {
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
 		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Runs all observable sequences in parallel and collect their last elements.
 		 *  
 		 * @example
 		 * res = Rx.Observable.forkJoin([obs1, obs2]);
-		 * @param sources Array of source sequences.
+		 * @param sources Array of source sequences or promises.
 		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
 		 */
 		forkJoin<T>(sources: Observable<T>[]): Observable<T[]>;
+		forkJoin<T>(sources: IPromise<T>[]): Observable<T[]>;
 
 		/**
 		 *  Runs all observable sequences in parallel and collect their last elements.
 		 *  
 		 * @example
 		 * res = Rx.Observable.forkJoin(obs1, obs2, ...);
-		 * @param args Source sequences.
+		 * @param args Source sequences or promises.
 		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
 		 */
 		forkJoin<T>(...args: Observable<T>[]): Observable<T[]>;
+		forkJoin<T>(...args: IPromise<T>[]): Observable<T[]>;
 	}
 }

From 44912732ea6b32e9d807068735ab03b57d6faac6 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 14 Apr 2014 11:31:43 +0400
Subject: [PATCH 6/6] Version bump to 2.2.20 for all other files

---
 rx.js/rx.binding.d.ts      | 2 +-
 rx.js/rx.coincidence.d.ts  | 2 +-
 rx.js/rx.joinpatterns.d.ts | 2 +-
 rx.js/rx.lite.d.ts         | 2 +-
 rx.js/rx.testing.d.ts      | 2 +-
 rx.js/rx.time.d.ts         | 2 +-
 rx.js/rx.virtualtime.d.ts  | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index 4d165a637..cf3744c4e 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Binding v2.2.18
+// Type definitions for RxJS-Binding v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.coincidence.d.ts b/rx.js/rx.coincidence.d.ts
index 02883ff54..bf9841b41 100644
--- a/rx.js/rx.coincidence.d.ts
+++ b/rx.js/rx.coincidence.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Coincidence package
+// Type definitions for RxJS-Coincidence v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.joinpatterns.d.ts b/rx.js/rx.joinpatterns.d.ts
index a1ec9f952..bc1ee2e32 100644
--- a/rx.js/rx.joinpatterns.d.ts
+++ b/rx.js/rx.joinpatterns.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Join package
+// Type definitions for RxJS-Join v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
diff --git a/rx.js/rx.lite.d.ts b/rx.js/rx.lite.d.ts
index e2640e9eb..e01b7e34b 100644
--- a/rx.js/rx.lite.d.ts
+++ b/rx.js/rx.lite.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Lite v2.2.18
+// Type definitions for RxJS-Lite v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.testing.d.ts b/rx.js/rx.testing.d.ts
index f03b2de08..082fdba59 100644
--- a/rx.js/rx.testing.d.ts
+++ b/rx.js/rx.testing.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Testing
+// Type definitions for RxJS-Testing v2.2.20
 // Project: https://github.com/Reactive-Extensions/RxJS/
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index 10290bfe8..18cccd4d3 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-Time v2.2.18
+// Type definitions for RxJS-Time v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts
index c57cbd664..bba46a761 100644
--- a/rx.js/rx.virtualtime.d.ts
+++ b/rx.js/rx.virtualtime.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-VirtualTime package 2.2.18
+// Type definitions for RxJS-VirtualTime v2.2.20
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>